diff --git a/pkg/dds/lib/src/dap/adapters/dart.dart b/pkg/dds/lib/src/dap/adapters/dart.dart
index 12fc769..f101d7b 100644
--- a/pkg/dds/lib/src/dap/adapters/dart.dart
+++ b/pkg/dds/lib/src/dap/adapters/dart.dart
@@ -12,6 +12,7 @@
 import '../exceptions.dart';
 import '../isolate_manager.dart';
 import '../logging.dart';
+import '../protocol_common.dart';
 import '../protocol_converter.dart';
 import '../protocol_generated.dart';
 import '../protocol_stream.dart';
@@ -253,6 +254,39 @@
     sendResponse(ContinueResponseBody(allThreadsContinued: false));
   }
 
+  /// [customRequest] handles any messages that do not match standard messages
+  /// in the spec.
+  ///
+  /// This is used to allow a client/DA to have custom methods outside of the
+  /// spec. It is up to the client/DA to negotiate which custom messages are
+  /// allowed.
+  ///
+  /// Implementations of this method must call super for any requests they are
+  /// not handling. The base implementation will reject the request as unknown.
+  ///
+  /// Custom message starting with _ are considered internal and are liable to
+  /// change without warning.
+  @override
+  Future<void> customRequest(
+    Request request,
+    RawRequestArguments? args,
+    void Function(Object?) sendResponse,
+  ) async {
+    switch (request.command) {
+
+      /// Used by tests to validate available protocols (eg. DDS). There may be
+      /// value in making this available to clients in future, but for now it's
+      /// internal.
+      case '_getSupportedProtocols':
+        final protocols = await vmService?.getSupportedProtocols();
+        sendResponse(protocols?.toJson());
+        break;
+
+      default:
+        await super.customRequest(request, args, sendResponse);
+    }
+  }
+
   /// Overridden by sub-classes to perform any additional setup after the VM
   /// Service is connected.
   Future<void> debuggerConnected(vm.VM vmInfo);
@@ -703,6 +737,27 @@
     sendResponse();
   }
 
+  /// Handles a request from the client for the list of threads.
+  ///
+  /// This is usually called after we sent a [StoppedEvent] to the client
+  /// notifying it that execution of an isolate has paused and it wants to
+  /// populate the threads view.
+  @override
+  Future<void> threadsRequest(
+    Request request,
+    void args,
+    void Function(ThreadsResponseBody) sendResponse,
+  ) async {
+    final threads = [
+      for (final thread in _isolateManager.threads)
+        Thread(
+          id: thread.threadId,
+          name: thread.isolate.name ?? '<unnamed isolate>',
+        )
+    ];
+    sendResponse(ThreadsResponseBody(threads: threads));
+  }
+
   /// [variablesRequest] is called by the client to request child variables for
   /// a given variables variablesReference.
   ///
diff --git a/pkg/dds/lib/src/dap/base_debug_adapter.dart b/pkg/dds/lib/src/dap/base_debug_adapter.dart
index e3c53db..4c09eb8 100644
--- a/pkg/dds/lib/src/dap/base_debug_adapter.dart
+++ b/pkg/dds/lib/src/dap/base_debug_adapter.dart
@@ -4,6 +4,8 @@
 
 import 'dart:async';
 
+import 'package:meta/meta.dart';
+
 import 'exceptions.dart';
 import 'logging.dart';
 import 'protocol_common.dart';
@@ -59,6 +61,22 @@
     void Function(ContinueResponseBody) sendResponse,
   );
 
+  @mustCallSuper
+  Future<void> customRequest(
+    Request request,
+    RawRequestArguments? args,
+    void Function(Object?) sendResponse,
+  ) async {
+    final response = Response(
+      success: false,
+      requestSeq: request.seq,
+      seq: _sequence++,
+      command: request.command,
+      message: 'Unknown command: ${request.command}',
+    );
+    sendResponse(response);
+  }
+
   Future<void> disconnectRequest(
     Request request,
     DisconnectArguments? args,
@@ -209,6 +227,12 @@
     void Function() sendResponse,
   );
 
+  Future<void> threadsRequest(
+    Request request,
+    void args,
+    void Function(ThreadsResponseBody) sendResponse,
+  );
+
   Future<void> variablesRequest(
     Request request,
     VariablesArguments args,
@@ -278,8 +302,13 @@
         StepInArguments.fromJson,
       );
     } else if (request.command == 'stepOut') {
-      handle(request, _withVoidResponse(stepOutRequest),
-          StepOutArguments.fromJson);
+      handle(
+        request,
+        _withVoidResponse(stepOutRequest),
+        StepOutArguments.fromJson,
+      );
+    } else if (request.command == 'threads') {
+      handle(request, threadsRequest, _voidArgs);
     } else if (request.command == 'stackTrace') {
       handle(request, stackTraceRequest, StackTraceArguments.fromJson);
     } else if (request.command == 'scopes') {
@@ -289,14 +318,11 @@
     } else if (request.command == 'evaluate') {
       handle(request, evaluateRequest, EvaluateArguments.fromJson);
     } else {
-      final response = Response(
-        success: false,
-        requestSeq: request.seq,
-        seq: _sequence++,
-        command: request.command,
-        message: 'Unknown command: ${request.command}',
+      handle(
+        request,
+        customRequest,
+        _allowNullArg(RawRequestArguments.fromJson),
       );
-      _channel.sendResponse(response);
     }
   }
 
@@ -305,6 +331,10 @@
     // (for example runInTerminalRequest).
   }
 
+  /// Helpers for requests that have `void` arguments. The supplied args are
+  /// ignored.
+  void _voidArgs(Map<String, Object?>? args) {}
+
   /// Helper that converts a handler with no response value to one that has
   /// passes an unused arg so that `Function()` can be passed to a function
   /// accepting `Function<T>(T x)` where `T` happens to be `void`.
diff --git a/pkg/dds/lib/src/dap/protocol_common.dart b/pkg/dds/lib/src/dap/protocol_common.dart
index 6295243..f9c09f4 100644
--- a/pkg/dds/lib/src/dap/protocol_common.dart
+++ b/pkg/dds/lib/src/dap/protocol_common.dart
@@ -8,6 +8,19 @@
   static bool canParse(Object? obj) => obj is Map<String, Object?>?;
 }
 
+/// A generic arguments class that just supplies the arguments map directly.
+///
+/// Used to support custom requests that may be provided by other implementing
+/// adapters that are not known at compile time by DDS/base DAP.
+class RawRequestArguments extends RequestArguments {
+  final Map<String, Object?> args;
+
+  RawRequestArguments.fromMap(this.args);
+
+  static RawRequestArguments fromJson(Map<String, Object?> obj) =>
+      RawRequestArguments.fromMap(obj);
+}
+
 /// A base class for (spec-generated) classes that represent the `arguments` of
 /// a request.
 abstract class RequestArguments {
diff --git a/pkg/dds/test/dap/integration/debug_test.dart b/pkg/dds/test/dap/integration/debug_test.dart
index f205ed5..b71a591 100644
--- a/pkg/dds/test/dap/integration/debug_test.dart
+++ b/pkg/dds/test/dap/integration/debug_test.dart
@@ -2,8 +2,11 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:collection/collection.dart';
 import 'package:test/test.dart';
+import 'package:vm_service/vm_service.dart';
 
+import 'test_client.dart';
 import 'test_support.dart';
 
 main() {
@@ -42,6 +45,46 @@
           'Exited.',
         ]);
       });
+
+      test('provides a list of threads', () async {
+        final client = dap.client;
+        final testFile = dap.createTestFile(r'''
+void main(List<String> args) async {
+  print('Hello!'); // BREAKPOINT
+}
+    ''');
+        final breakpointLine = lineWith(testFile, '// BREAKPOINT');
+
+        await client.hitBreakpoint(testFile, breakpointLine);
+        final response = await client.getValidThreads();
+
+        expect(response.threads, hasLength(1));
+        expect(response.threads.first.name, equals('main'));
+      });
+
+      test('connects with DDS', () async {
+        final client = dap.client;
+        final testFile = dap.createTestFile(r'''
+void main(List<String> args) async {
+  print('Hello!'); // BREAKPOINT
+}
+    ''');
+        final breakpointLine = lineWith(testFile, '// BREAKPOINT');
+
+        await client.hitBreakpoint(testFile, breakpointLine);
+        final response = await client.custom(
+          '_getSupportedProtocols',
+          null,
+        );
+
+        // For convenience, use the ProtocolList to deserialise the custom
+        // response to check if included DDS.
+        final protocolList =
+            ProtocolList.parse(response.body as Map<String, Object?>?);
+        final ddsProtocol = protocolList?.protocols
+            ?.singleWhereOrNull((protocol) => protocol.protocolName == "DDS");
+        expect(ddsProtocol, isNot(isNull));
+      });
       // These tests can be slow due to starting up the external server process.
     }, timeout: Timeout.none);
   });
diff --git a/pkg/dds/test/dap/integration/test_client.dart b/pkg/dds/test/dap/integration/test_client.dart
index f1fade0..3912205 100644
--- a/pkg/dds/test/dap/integration/test_client.dart
+++ b/pkg/dds/test/dap/integration/test_client.dart
@@ -77,6 +77,11 @@
   Future<Response> continue_(int threadId) =>
       sendRequest(ContinueArguments(threadId: threadId));
 
+  /// Sends a custom request to the server and waits for a response.
+  Future<Response> custom(String name, Object? args) async {
+    return sendRequest(args, overrideCommand: name);
+  }
+
   Future<Response> disconnect() => sendRequest(DisconnectArguments());
 
   /// Sends an evaluate request for the given [expression], optionally for a
@@ -225,6 +230,13 @@
 
   Future<Response> terminate() => sendRequest(TerminateArguments());
 
+  /// Sends a threads request to the server to request the list of active
+  /// threads (isolates).
+  ///
+  /// Returns a Future that completes when the server returns a corresponding
+  /// response.
+  Future<Response> threads() => sendRequest(null, overrideCommand: 'threads');
+
   /// Sends a request for child variables (fields/list elements/etc.) for the
   /// variable with reference [variablesReference].
   ///
@@ -396,6 +408,14 @@
         response.body as Map<String, Object?>);
   }
 
+  /// Fetches threads and asserts a valid response.
+  Future<ThreadsResponseBody> getValidThreads() async {
+    final response = await threads();
+    expect(response.success, isTrue);
+    expect(response.command, equals('threads'));
+    return ThreadsResponseBody.fromJson(response.body as Map<String, Object?>);
+  }
+
   /// A helper that fetches scopes for a frame, checks for one with the name
   /// [expectedName] and verifies its variables.
   Future<Scope> expectScopeVariables(
diff --git a/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart b/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
index d83b346..d7acc90 100644
--- a/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
+++ b/pkg/dev_compiler/lib/src/compiler/shared_compiler.dart
@@ -331,18 +331,6 @@
     return symbolId;
   }
 
-  /// Emits a private name JS Symbol for [memberName] unique to a Dart
-  /// class [className].
-  ///
-  /// This is now required for fields of constant objects that may be
-  /// overridden within the same library.
-  @protected
-  js_ast.TemporaryId emitClassPrivateNameSymbol(
-      Library library, String className, String memberName,
-      [js_ast.TemporaryId id]) {
-    return emitPrivateNameSymbol(library, '$className.$memberName', id);
-  }
-
   /// Emits an expression to set the property [nameExpr] on the class [className],
   /// with [value].
   ///
diff --git a/pkg/dev_compiler/lib/src/kernel/command.dart b/pkg/dev_compiler/lib/src/kernel/command.dart
index fc521de..c0e4c51 100644
--- a/pkg/dev_compiler/lib/src/kernel/command.dart
+++ b/pkg/dev_compiler/lib/src/kernel/command.dart
@@ -747,8 +747,14 @@
     for (var e in compiler.classIdentifiers.entries)
       e.key: identifierNames[e.value],
   };
+  var variableJsNames = <VariableDeclaration, String>{
+    for (var e in compiler.variableIdentifiers.entries)
+      e.key: identifierNames[e.value],
+  };
 
-  return ModuleSymbolsCollector(classJsNames).collectSymbolInfo(component);
+  return ModuleSymbolsCollector(
+          classJsNames, compiler.memberNames, variableJsNames)
+      .collectSymbolInfo(component);
 }
 
 ModuleMetadata _emitMetadata(js_ast.Program program, Component component,
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index e6d2dbf..b68b8c1 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -53,6 +53,20 @@
   /// module.
   final classIdentifiers = <Class, js_ast.Identifier>{};
 
+  /// Maps each class `Member` node compiled in the module to the name used for
+  /// the member in JavaScript.
+  ///
+  /// This mapping is used when generating the symbol information for the
+  /// module.
+  final memberNames = <Member, String>{};
+
+  /// Maps each `VariableDeclaration` node compiled in the module to the name
+  /// used for the variable in JavaScript.
+  ///
+  /// This mapping is used when generating the symbol information for the
+  /// module.
+  final variableIdentifiers = <VariableDeclaration, js_ast.Identifier>{};
+
   /// Maps a library URI import, that is not in [_libraries], to the
   /// corresponding Kernel summary module we imported it with.
   ///
@@ -663,8 +677,8 @@
       // is called multiple times, that symbol is cached.  If the former,
       // assign directly to [virtualField].  If the latter, copy the old
       // variable to [virtualField].
-      var symbol = emitClassPrivateNameSymbol(c.enclosingLibrary,
-          getLocalClassName(c), field.name.text, virtualField);
+      var symbol = _emitClassPrivateNameSymbol(
+          c.enclosingLibrary, getLocalClassName(c), field, virtualField);
       if (symbol != virtualField) {
         addSymbol(virtualField, getSymbolValue(symbol));
         if (!containerizeSymbols) {
@@ -2236,7 +2250,7 @@
   js_ast.Statement _emitLazyFields(
       js_ast.Expression objExpr,
       Iterable<Field> fields,
-      js_ast.Expression Function(Field f) emitFieldName) {
+      js_ast.LiteralString Function(Field f) emitFieldName) {
     var accessors = <js_ast.Method>[];
     var savedUri = _currentUri;
 
@@ -2244,6 +2258,7 @@
       _currentUri = field.fileUri;
       _staticTypeContext.enterMember(field);
       var access = emitFieldName(field);
+      memberNames[field] = access.valueWithoutQuotes;
       accessors.add(js_ast.Method(access, _emitStaticFieldInitializer(field),
           isGetter: true)
         ..sourceInformation = _hoverComment(
@@ -2352,6 +2367,7 @@
       Class memberClass}) {
     // Static members skip the rename steps and may require JS interop renames.
     if (isStatic) {
+      // TODO(nshahan) Record the name for this member in memberNames.
       return _emitStaticMemberName(name, member);
     }
 
@@ -2368,6 +2384,7 @@
         for (var i = 1; i < parts.length; i++) {
           result = js_ast.PropertyAccess(result, propertyName(parts[i]));
         }
+        // TODO(nshahan) Record the name for this member in memberNames.
         return result;
       }
     }
@@ -2378,15 +2395,19 @@
       var memberLibrary = member?.name?.library ??
           memberClass?.enclosingLibrary ??
           _currentLibrary;
+      // TODO(nshahan) Record the name for this member in memberNames.
       return getSymbol(emitPrivateNameSymbol(memberLibrary, name));
     }
 
     useExtension ??= _isSymbolizedMember(memberClass, name);
     name = js_ast.memberNameForDartMember(name, _isExternal(member));
     if (useExtension) {
+      // TODO(nshahan) Record the name for this member in memberNames.
       return getSymbol(getExtensionSymbolInternal(name));
     }
-    return propertyName(name);
+    var memberName = propertyName(name);
+    memberNames[member] = memberName.valueWithoutQuotes;
+    return memberName;
   }
 
   /// Don't symbolize native members that just forward to the underlying
@@ -2440,7 +2461,7 @@
             _hierarchy.getDispatchTarget(c, Name(name), setter: true));
   }
 
-  js_ast.Expression _emitStaticMemberName(String name, [NamedNode member]) {
+  js_ast.LiteralString _emitStaticMemberName(String name, [NamedNode member]) {
     if (member != null) {
       var jsName = _emitJSInteropStaticMemberName(member);
       if (jsName != null) return jsName;
@@ -2491,7 +2512,7 @@
     return f;
   }
 
-  js_ast.Expression _emitJSInteropStaticMemberName(NamedNode n) {
+  js_ast.LiteralString _emitJSInteropStaticMemberName(NamedNode n) {
     if (!usesJSInterop(n)) return null;
     var name = _annotationName(n, isPublicJSAnnotation);
     if (name != null) {
@@ -2526,7 +2547,8 @@
   ///
   /// NOTE: usually you should use [_emitTopLevelName] instead of this. This
   /// function does not handle JS interop.
-  js_ast.Expression _emitTopLevelMemberName(NamedNode n, {String suffix = ''}) {
+  js_ast.LiteralString _emitTopLevelMemberName(NamedNode n,
+      {String suffix = ''}) {
     var name = _jsExportName(n) ?? getTopLevelName(n);
     return propertyName(name + suffix);
   }
@@ -4485,9 +4507,13 @@
     var name = v.name;
     if (name == null || name.startsWith('#')) {
       name = name == null ? 't${_tempVariables.length}' : name.substring(1);
+      // TODO(nshahan) Record the Identifier for this variable in
+      // variableIdentifiers.
       return _tempVariables.putIfAbsent(v, () => _emitTemporaryId(name));
     }
-    return _emitIdentifier(name);
+    var identifier = _emitIdentifier(name);
+    variableIdentifiers[v] = identifier;
+    return identifier;
   }
 
   /// Emits the declaration of a variable.
@@ -6356,8 +6382,8 @@
       // was overridden.
       var symbol = cls.isEnum
           ? _emitMemberName(member.name.text, member: member)
-          : getSymbol(emitClassPrivateNameSymbol(
-              cls.enclosingLibrary, getLocalClassName(cls), member.name.text));
+          : getSymbol(_emitClassPrivateNameSymbol(
+              cls.enclosingLibrary, getLocalClassName(cls), member));
       return js_ast.Property(symbol, constant);
     }
 
@@ -6374,6 +6400,20 @@
         js_ast.ObjectInitializer(properties, multiline: true));
   }
 
+  /// Emits a private name JS Symbol for [member] unique to a Dart class
+  /// [className].
+  ///
+  /// This is now required for fields of constant objects that may be overridden
+  /// within the same library.
+  js_ast.TemporaryId _emitClassPrivateNameSymbol(
+      Library library, String className, Member member,
+      [js_ast.TemporaryId id]) {
+    var name = '$className.${member.name.text}';
+    // Names used in the symbols for the public fields
+    // memberNames[member] = 'Symbol($name)';
+    return emitPrivateNameSymbol(library, name, id);
+  }
+
   @override
   js_ast.Expression visitTearOffConstant(TearOffConstant node) {
     _declareBeforeUse(node.procedure.enclosingClass);
diff --git a/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart b/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
index bf405a2..253facf 100644
--- a/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
+++ b/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
@@ -9,48 +9,60 @@
 import 'module_symbols.dart';
 
 class ModuleSymbolsCollector extends RecursiveVisitor {
-  final scopes = <ScopeSymbol>[];
+  /// Stack of active scopes while visiting the original Dart program.
+  ///
+  /// The first scope added to the stack should always be the library scope. The
+  /// last element in the list represents the current scope.
+  final _scopes = <ScopeSymbol>[];
 
-  final moduleSymbols = ModuleSymbols(
-    // TODO version
-    // TODO moduleName
-    libraries: <LibrarySymbol>[],
-    scripts: <Script>[],
-    classes: <ClassSymbol>[],
-    // TODO functionTypes
-    // TODO functions
-    // TODO scopes
-    // TODO variables
-  );
+  final _moduleSymbols = ModuleSymbols(
+      // TODO(nshahan) version
+      // TODO(nshahan) moduleName
+      libraries: <LibrarySymbol>[],
+      scripts: <Script>[],
+      classes: <ClassSymbol>[],
+      // TODO(nshahan) functionTypes
+      // TODO(nshahan) functions
+      // TODO(nshahan) scopes
+      variables: <VariableSymbol>[]);
 
-  final Map<Class, String> classJsNames;
+  final Map<Class, String> _classJsNames;
+  final Map<Member, String> _memberJsNames;
+  final Map<VariableDeclaration, String> _variableJsNames;
 
-  ModuleSymbolsCollector(this.classJsNames);
+  ModuleSymbolsCollector(
+      this._classJsNames, this._memberJsNames, this._variableJsNames);
 
   ModuleSymbols collectSymbolInfo(Component node) {
     node.accept(this);
-    return moduleSymbols;
+    return _moduleSymbols;
   }
 
   /// Returns the id of the script in this module with the matching [fileUri].
   String _scriptId(Uri fileUri) => fileUri.toString();
 
+  /// Returns the id of [type].
+  String _typeId(DartType type) =>
+      // TODO(nshahan) How to handle function types or types from other modules?
+      type is InterfaceType ? _classJsNames[type.classNode] : null;
+
   @override
   void visitClass(Class node) {
     var classSymbol = ClassSymbol(
         name: node.name,
         isAbstract: node.isAbstract,
-        // TODO isConst - has a const constructor?
-        superClassId: classJsNames[node.superclass],
+        // TODO(nshahan) isConst - Does this mean has a const constructor?
+        superClassId: _classJsNames[node.superclass],
         interfaceIds: [
-          for (var type in node.implementedTypes) classJsNames[type.classNode]
+          for (var type in node.implementedTypes) _classJsNames[type.classNode]
         ],
         typeParameters: {
           for (var param in node.typeParameters)
-            param.name: param.name // TODO: value should be JS name
+            // TODO(nshahan) Value should be the JS name.
+            param.name: param.name
         },
-        localId: classJsNames[node],
-        scopeId: scopes.last.id,
+        localId: _classJsNames[node],
+        scopeId: _scopes.last.id,
         location: SourceLocation(
             scriptId: _scriptId(node.location.file),
             tokenPos: node.startFileOffset,
@@ -59,12 +71,33 @@
         variableIds: <String>[],
         scopeIds: <String>[]);
 
-    scopes.add(classSymbol);
+    _scopes.add(classSymbol);
     node.visitChildren(this);
-    scopes
+    _scopes
       ..removeLast()
       ..last.scopeIds.add(classSymbol.id);
-    moduleSymbols.classes.add(classSymbol);
+    _moduleSymbols.classes.add(classSymbol);
+  }
+
+  @override
+  void visitField(Field node) {
+    var fieldSymbol = VariableSymbol(
+        name: node.name.text,
+        kind: node.parent is Class
+            ? VariableSymbolKind.field
+            : VariableSymbolKind.global,
+        isConst: node.isConst,
+        isFinal: node.isFinal,
+        isStatic: node.isStatic,
+        typeId: _typeId(node.type),
+        localId: _memberJsNames[node],
+        scopeId: _scopes.last.id,
+        location: SourceLocation(
+            scriptId: _scriptId(node.location.file),
+            tokenPos: node.fileOffset));
+    node.visitChildren(this);
+    _scopes.last.variableIds.add(fieldSymbol.id);
+    _moduleSymbols.variables.add(fieldSymbol);
   }
 
   @override
@@ -77,13 +110,13 @@
             LibrarySymbolDependency(
                 isImport: dep.isImport,
                 isDeferred: dep.isDeferred,
-                // TODO prefix
+                // TODO(nshahan) Need to handle prefixes.
                 targetId: dep.targetLibrary.importUri.toString())
         ],
         variableIds: <String>[],
         scopeIds: <String>[]);
 
-    // TODO: Save some space by using integers as local ids?
+    // TODO(nshahan) Save some space by using integers as local ids?
     var scripts = [
       Script(
           uri: node.fileUri.toString(),
@@ -97,11 +130,47 @@
     ];
 
     librarySymbol.scriptIds = [for (var script in scripts) script.id];
-    moduleSymbols.scripts.addAll(scripts);
+    _moduleSymbols.scripts.addAll(scripts);
 
-    scopes.add(librarySymbol);
+    _scopes.add(librarySymbol);
     node.visitChildren(this);
-    scopes.removeLast();
-    moduleSymbols.libraries.add(librarySymbol);
+    _scopes.removeLast();
+    _moduleSymbols.libraries.add(librarySymbol);
   }
+
+  @override
+  void visitProcedure(Procedure node) {
+    // Legacy libraries contain procedures with no bodies for all Object methods
+    // in every class. We can ignore these unless they actually contain a body.
+    if (node.function.body == null) return;
+    // TODO(nshahan) implement visitProcedure
+    super.visitProcedure(node);
+  }
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    var kind = node.isFieldFormal
+        ? VariableSymbolKind.formal
+        : VariableSymbolKind.local;
+    var variableSymbol = _createVariableSymbol(node, kind);
+    node.visitChildren(this);
+    _scopes.last.variableIds.add(variableSymbol.id);
+    _moduleSymbols.variables.add(variableSymbol);
+  }
+
+  VariableSymbol _createVariableSymbol(
+          VariableDeclaration node, VariableSymbolKind kind) =>
+      VariableSymbol(
+          name: node.name,
+          kind: kind,
+          isConst: node.isConst,
+          isFinal: node.isFinal,
+          // Static fields are visited in `visitField()`.
+          isStatic: false,
+          typeId: _typeId(node.type),
+          localId: _variableJsNames[node],
+          scopeId: _scopes.last.id,
+          location: SourceLocation(
+              scriptId: _scriptId(node.location.file),
+              tokenPos: node.fileOffset));
 }
diff --git a/pkg/dev_compiler/test/module_symbols/class_symbols_test.dart b/pkg/dev_compiler/test/module_symbols/class_symbols_test.dart
new file mode 100644
index 0000000..aacf754
--- /dev/null
+++ b/pkg/dev_compiler/test/module_symbols/class_symbols_test.dart
@@ -0,0 +1,298 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart = 2.9
+
+import 'package:dev_compiler/src/kernel/module_symbols.dart';
+import 'package:test/test.dart';
+
+import '../shared_test_options.dart';
+import 'module_symbols_test_shared.dart';
+
+void main() async {
+  for (var mode in [
+    NullSafetyTestOption('Sound Mode:', true),
+    NullSafetyTestOption('Weak Mode:', false)
+  ]) {
+    group(mode.description, () {
+      var options = SetupCompilerOptions(soundNullSafety: mode.soundNullSafety);
+      group('simple class debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {}
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('has name', () async {
+          expect(classSymbol.name, equals('A'));
+        });
+        test('is not abstract', () async {
+          expect(classSymbol.isAbstract, isFalse);
+        });
+        // TODO test isConst
+        test('has no superclassId', () async {
+          expect(classSymbol.superClassId, isNull);
+        });
+        test('empty interfacesIds', () async {
+          expect(classSymbol.interfaceIds, isEmpty);
+        });
+        test('empty typeParameters', () async {
+          expect(classSymbol.typeParameters, isEmpty);
+        });
+        test('has localId', () async {
+          expect(classSymbol.localId, equals('A'));
+        });
+        test('has library scopeId', () async {
+          expect(classSymbol.scopeId, endsWith('package:foo/foo.dart'));
+        });
+        group('location', () {
+          test('has scriptId', () async {
+            expect(classSymbol.location.scriptId, endsWith('/foo.dart'));
+          });
+          test('has start token', () async {
+            expect(classSymbol.location.tokenPos,
+                22 + options.dartLangComment.length);
+          });
+          test('has end token', () async {
+            expect(classSymbol.location.endTokenPos,
+                31 + options.dartLangComment.length);
+          });
+        });
+        test('no fields', () async {
+          expect(classSymbol.variableIds, isEmpty);
+        });
+        // TODO only has the implicit constructor in scopeIds.
+      });
+      group('abstract class debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          abstract class A {}
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('is abstract', () async {
+          expect(classSymbol.isAbstract, isTrue);
+        });
+      });
+      group('class extends debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A extends B {}
+
+          class B {}
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol =
+              result.symbols.classes.where((c) => c.localId == 'A').single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('has superclass', () async {
+          expect(classSymbol.superClassId, 'B');
+        });
+      });
+      group('class implements debug symbols', () {
+        TestDriver driver;
+        List<ClassSymbol> classSymbols;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A implements B, C {}
+
+          class B implements C {}
+
+          class C {}
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbols = result.symbols.classes;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('single implements', () async {
+          var classSymbol = classSymbols.singleWhere((c) => c.localId == 'B');
+          expect(classSymbol.interfaceIds, orderedEquals(['C']));
+        });
+        test('multiple implements', () async {
+          var classSymbol = classSymbols.singleWhere((c) => c.localId == 'A');
+          expect(classSymbol.interfaceIds, orderedEquals(['B', 'C']));
+        });
+      });
+      group('class public static field debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        String fieldId;
+        VariableSymbol fieldSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {
+            static String publicStaticField = 'Cello';
+          }
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+          fieldId = classSymbol.fieldIds.single;
+          fieldSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('fieldId in classSymbol', () async {
+          expect(fieldId, endsWith('A|publicStaticField'));
+          expect(fieldId, fieldSymbol.id);
+        });
+        test('has class scopeId', () async {
+          expect(fieldSymbol.scopeId, endsWith('|A'));
+          expect(fieldSymbol.scopeId, classSymbol.id);
+        });
+        test('is field', () async {
+          expect(fieldSymbol.kind, VariableSymbolKind.field);
+        });
+        test('is static', () async {
+          expect(fieldSymbol.isStatic, isTrue);
+        });
+      });
+      group('class private static field debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        String fieldId;
+        VariableSymbol fieldSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {
+            static String _privateStaticField = 'Fosse';
+          }
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+          fieldId = classSymbol.fieldIds.single;
+          fieldSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('fieldId in classSymbol', () async {
+          expect(fieldId, endsWith('A|_privateStaticField'));
+          expect(fieldId, fieldSymbol.id);
+        });
+        test('has class scopeId', () async {
+          expect(fieldSymbol.scopeId, endsWith('|A'));
+          expect(fieldSymbol.scopeId, classSymbol.id);
+        });
+        test('is field', () async {
+          expect(fieldSymbol.kind, VariableSymbolKind.field);
+        });
+        test('is static', () async {
+          expect(fieldSymbol.isStatic, isTrue);
+        });
+      });
+      group('class public instance field debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        String fieldId;
+        VariableSymbol fieldSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {
+            String publicInstanceField = 'Cello';
+          }
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+          fieldId = classSymbol.fieldIds.single;
+          fieldSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('fieldId in classSymbol', () async {
+          expect(fieldId, endsWith('A|publicInstanceField'));
+          expect(fieldId, fieldSymbol.id);
+        });
+        test('has class scopeId', () async {
+          expect(fieldSymbol.scopeId, endsWith('|A'));
+          expect(fieldSymbol.scopeId, classSymbol.id);
+        });
+        test('is field', () async {
+          expect(fieldSymbol.kind, VariableSymbolKind.field);
+        });
+        test('is not static', () async {
+          expect(fieldSymbol.isStatic, isFalse);
+        });
+      });
+      group('class private instance field debug symbols', () {
+        TestDriver driver;
+        ClassSymbol classSymbol;
+        String fieldId;
+        VariableSymbol fieldSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {
+            String privateInstanceField = 'Cello';
+          }
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          classSymbol = result.symbols.classes.single;
+          fieldId = classSymbol.fieldIds.single;
+          fieldSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('fieldId in classSymbol', () async {
+          expect(fieldId, endsWith('A|privateInstanceField'));
+          expect(fieldId, fieldSymbol.id);
+        });
+        test('has class scopeId', () async {
+          expect(fieldSymbol.scopeId, endsWith('|A'));
+          expect(fieldSymbol.scopeId, classSymbol.id);
+        });
+        test('is field', () async {
+          expect(fieldSymbol.kind, VariableSymbolKind.field);
+        });
+        test('is not static', () async {
+          expect(fieldSymbol.isStatic, isFalse);
+        });
+      });
+    });
+  }
+}
diff --git a/pkg/dev_compiler/test/module_symbols/module_symbols_test.dart b/pkg/dev_compiler/test/module_symbols/module_symbols_test.dart
deleted file mode 100644
index 20fbfc1..0000000
--- a/pkg/dev_compiler/test/module_symbols/module_symbols_test.dart
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// @dart = 2.9
-
-import 'dart:io' show Directory, File;
-
-import 'package:dev_compiler/dev_compiler.dart';
-import 'package:dev_compiler/src/kernel/command.dart';
-import 'package:dev_compiler/src/kernel/module_symbols.dart';
-import 'package:kernel/ast.dart' show Component, Library;
-import 'package:test/test.dart';
-
-import '../shared_test_options.dart';
-
-class TestCompiler {
-  final SetupCompilerOptions setup;
-
-  TestCompiler(this.setup);
-
-  Future<JSCode> compile({Uri input, Uri packages}) async {
-    // Initialize incremental compiler and create component.
-    setup.options.packagesFileUri = packages;
-    var compiler = DevelopmentIncrementalCompiler(setup.options, input);
-    var component = await compiler.computeDelta();
-    component.computeCanonicalNames();
-
-    // Initialize DDC.
-    var moduleName = 'foo.dart';
-    var classHierarchy = compiler.getClassHierarchy();
-    var compilerOptions = SharedCompilerOptions(
-        replCompile: true,
-        moduleName: moduleName,
-        soundNullSafety: setup.soundNullSafety,
-        moduleFormats: [setup.moduleFormat],
-        emitDebugSymbols: true);
-    var coreTypes = compiler.getCoreTypes();
-
-    final importToSummary = Map<Library, Component>.identity();
-    final summaryToModule = Map<Component, String>.identity();
-    for (var lib in component.libraries) {
-      importToSummary[lib] = component;
-    }
-    summaryToModule[component] = moduleName;
-
-    // Compile Kernel AST to JS AST.
-    var kernel2jsCompiler = ProgramCompiler(component, classHierarchy,
-        compilerOptions, importToSummary, summaryToModule,
-        coreTypes: coreTypes);
-    var moduleTree = kernel2jsCompiler.emitModule(component);
-
-    // Compile JS AST to code.
-    return jsProgramToCode(moduleTree, ModuleFormat.amd,
-        emitDebugSymbols: true,
-        compiler: kernel2jsCompiler,
-        component: component);
-  }
-}
-
-class TestDriver {
-  final SetupCompilerOptions options;
-  Directory tempDir;
-  final String source;
-  Uri input;
-  Uri packages;
-  File file;
-
-  TestDriver(this.options, this.source) {
-    var systemTempDir = Directory.systemTemp;
-    tempDir = systemTempDir.createTempSync('foo bar');
-
-    input = tempDir.uri.resolve('foo.dart');
-    file = File.fromUri(input)..createSync();
-    file.writeAsStringSync(source);
-
-    packages = tempDir.uri.resolve('package_config.json');
-    file = File.fromUri(packages)..createSync();
-    file.writeAsStringSync('''
-      {
-        "configVersion": 2,
-        "packages": [
-          {
-            "name": "foo",
-            "rootUri": "./",
-            "packageUri": "./"
-          }
-        ]
-      }
-      ''');
-  }
-
-  Future<JSCode> compile() async =>
-      await TestCompiler(options).compile(input: input, packages: packages);
-
-  void cleanUp() {
-    tempDir.delete(recursive: true);
-  }
-}
-
-class NullSafetyTestOption {
-  final String description;
-  final bool soundNullSafety;
-
-  NullSafetyTestOption(this.description, this.soundNullSafety);
-}
-
-void main() async {
-  for (var mode in [
-    NullSafetyTestOption('Sound Mode:', true),
-    NullSafetyTestOption('Weak Mode:', false)
-  ]) {
-    group(mode.description, () {
-      var options = SetupCompilerOptions(soundNullSafety: mode.soundNullSafety);
-      group('simple class debug symbols', () {
-        TestDriver driver;
-        ClassSymbol classSymbol;
-        final source = '''
-          ${options.dartLangComment}
-
-          class A {}
-          ''';
-        setUpAll(() async {
-          driver = TestDriver(options, source);
-          var result = await driver.compile();
-          classSymbol = result.symbols.classes.single;
-        });
-        tearDownAll(() {
-          driver.cleanUp();
-        });
-        test('has name', () async {
-          expect(classSymbol.name, equals('A'));
-        });
-        test('is not abstract', () async {
-          expect(classSymbol.isAbstract, isFalse);
-        });
-        // TODO test isConst
-        test('has no superclassId', () async {
-          expect(classSymbol.superClassId, isNull);
-        });
-        test('empty interfacesIds', () async {
-          expect(classSymbol.interfaceIds, isEmpty);
-        });
-        test('empty typeParameters', () async {
-          expect(classSymbol.typeParameters, isEmpty);
-        });
-        test('has localId', () async {
-          expect(classSymbol.localId, equals('A'));
-        });
-        test('has library scopeId', () async {
-          expect(classSymbol.scopeId, endsWith('package:foo/foo.dart'));
-        });
-        group('location', () {
-          test('has scriptId', () async {
-            expect(classSymbol.location.scriptId, endsWith('/foo.dart'));
-          });
-          test('has start token', () async {
-            expect(classSymbol.location.tokenPos,
-                22 + options.dartLangComment.length);
-          });
-          test('has end token', () async {
-            expect(classSymbol.location.endTokenPos,
-                31 + options.dartLangComment.length);
-          });
-        });
-        test('no fields', () async {
-          expect(classSymbol.variableIds, isEmpty);
-        });
-        // TODO only has the implicit constructor in scopeIds.
-      });
-      group('abstract class debug symbols', () {
-        TestDriver driver;
-        ClassSymbol classSymbol;
-        final source = '''
-          ${options.dartLangComment}
-
-          abstract class A {}
-          ''';
-        setUpAll(() async {
-          driver = TestDriver(options, source);
-          var result = await driver.compile();
-          classSymbol = result.symbols.classes.single;
-        });
-        tearDownAll(() {
-          driver.cleanUp();
-        });
-        test('is abstract', () async {
-          expect(classSymbol.isAbstract, isTrue);
-        });
-      });
-      group('class extends debug symbols', () {
-        TestDriver driver;
-        ClassSymbol classSymbol;
-        final source = '''
-          ${options.dartLangComment}
-
-          class A extends B {}
-
-          class B {}
-          ''';
-        setUpAll(() async {
-          driver = TestDriver(options, source);
-          var result = await driver.compile();
-          classSymbol =
-              result.symbols.classes.where((c) => c.localId == 'A').single;
-        });
-        tearDownAll(() {
-          driver.cleanUp();
-        });
-        test('has superclass', () async {
-          expect(classSymbol.superClassId, 'B');
-        });
-      });
-      group('class implements debug symbols', () {
-        TestDriver driver;
-        List<ClassSymbol> classSymbols;
-        final source = '''
-          ${options.dartLangComment}
-
-          class A implements B, C {}
-
-          class B implements C {}
-
-          class C {}
-          ''';
-        setUpAll(() async {
-          driver = TestDriver(options, source);
-          var result = await driver.compile();
-          classSymbols = result.symbols.classes;
-        });
-        tearDownAll(() {
-          driver.cleanUp();
-        });
-        test('single implements', () async {
-          var classSymbol = classSymbols.singleWhere((c) => c.localId == 'B');
-          expect(classSymbol.interfaceIds, orderedEquals(['C']));
-        });
-        test('multiple implements', () async {
-          var classSymbol = classSymbols.singleWhere((c) => c.localId == 'A');
-          expect(classSymbol.interfaceIds, orderedEquals(['B', 'C']));
-        });
-      });
-    });
-  }
-}
diff --git a/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart b/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart
new file mode 100644
index 0000000..13bdd4a
--- /dev/null
+++ b/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart
@@ -0,0 +1,104 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart = 2.9
+
+import 'dart:io' show Directory, File;
+
+import 'package:dev_compiler/dev_compiler.dart';
+import 'package:dev_compiler/src/kernel/command.dart';
+import 'package:kernel/ast.dart' show Component, Library;
+
+import '../shared_test_options.dart';
+
+class TestCompiler {
+  final SetupCompilerOptions setup;
+
+  TestCompiler(this.setup);
+
+  Future<JSCode> compile({Uri input, Uri packages}) async {
+    // Initialize incremental compiler and create component.
+    setup.options.packagesFileUri = packages;
+    var compiler = DevelopmentIncrementalCompiler(setup.options, input);
+    var component = await compiler.computeDelta();
+    component.computeCanonicalNames();
+
+    // Initialize DDC.
+    var moduleName = 'foo.dart';
+    var classHierarchy = compiler.getClassHierarchy();
+    var compilerOptions = SharedCompilerOptions(
+        replCompile: true,
+        moduleName: moduleName,
+        soundNullSafety: setup.soundNullSafety,
+        moduleFormats: [setup.moduleFormat],
+        emitDebugSymbols: true);
+    var coreTypes = compiler.getCoreTypes();
+
+    final importToSummary = Map<Library, Component>.identity();
+    final summaryToModule = Map<Component, String>.identity();
+    for (var lib in component.libraries) {
+      importToSummary[lib] = component;
+    }
+    summaryToModule[component] = moduleName;
+
+    // Compile Kernel AST to JS AST.
+    var kernel2jsCompiler = ProgramCompiler(component, classHierarchy,
+        compilerOptions, importToSummary, summaryToModule,
+        coreTypes: coreTypes);
+    var moduleTree = kernel2jsCompiler.emitModule(component);
+
+    // Compile JS AST to code.
+    return jsProgramToCode(moduleTree, ModuleFormat.amd,
+        emitDebugSymbols: true,
+        compiler: kernel2jsCompiler,
+        component: component);
+  }
+}
+
+class TestDriver {
+  final SetupCompilerOptions options;
+  Directory tempDir;
+  final String source;
+  Uri input;
+  Uri packages;
+  File file;
+
+  TestDriver(this.options, this.source) {
+    var systemTempDir = Directory.systemTemp;
+    tempDir = systemTempDir.createTempSync('foo bar');
+
+    input = tempDir.uri.resolve('foo.dart');
+    file = File.fromUri(input)..createSync();
+    file.writeAsStringSync(source);
+
+    packages = tempDir.uri.resolve('package_config.json');
+    file = File.fromUri(packages)..createSync();
+    file.writeAsStringSync('''
+      {
+        "configVersion": 2,
+        "packages": [
+          {
+            "name": "foo",
+            "rootUri": "./",
+            "packageUri": "./"
+          }
+        ]
+      }
+      ''');
+  }
+
+  Future<JSCode> compile() async =>
+      await TestCompiler(options).compile(input: input, packages: packages);
+
+  void cleanUp() {
+    tempDir.delete(recursive: true);
+  }
+}
+
+class NullSafetyTestOption {
+  final String description;
+  final bool soundNullSafety;
+
+  NullSafetyTestOption(this.description, this.soundNullSafety);
+}
diff --git a/pkg/dev_compiler/test/module_symbols/variable_symbols_test.dart b/pkg/dev_compiler/test/module_symbols/variable_symbols_test.dart
new file mode 100644
index 0000000..f74b54c
--- /dev/null
+++ b/pkg/dev_compiler/test/module_symbols/variable_symbols_test.dart
@@ -0,0 +1,116 @@
+// Copyright (c) 2021, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart = 2.9
+
+import 'package:dev_compiler/src/kernel/module_symbols.dart';
+import 'package:test/test.dart';
+
+import '../shared_test_options.dart';
+import 'module_symbols_test_shared.dart';
+
+void main() async {
+  for (var mode in [
+    NullSafetyTestOption('Sound Mode:', true),
+    NullSafetyTestOption('Weak Mode:', false)
+  ]) {
+    group(mode.description, () {
+      var options = SetupCompilerOptions(soundNullSafety: mode.soundNullSafety);
+      group('global variable debug symbols', () {
+        TestDriver driver;
+        VariableSymbol variableSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {}
+          var globalVariable = A();
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          variableSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('has name', () async {
+          expect(variableSymbol.name, equals('globalVariable'));
+        });
+        test('is global', () async {
+          expect(variableSymbol.kind, VariableSymbolKind.global);
+        });
+        test('is not const', () async {
+          expect(variableSymbol.isConst, false);
+        });
+        test('is not final', () async {
+          expect(variableSymbol.isFinal, false);
+        });
+        test('is static', () async {
+          expect(variableSymbol.isStatic, true);
+        });
+        test('has interface type id', () async {
+          expect(variableSymbol.typeId, 'A');
+        });
+        test('has localId', () async {
+          expect(variableSymbol.localId, 'globalVariable');
+        });
+        test('has library scopeId', () async {
+          expect(variableSymbol.scopeId, endsWith('package:foo/foo.dart'));
+        });
+        group('location', () {
+          test('has scriptId', () async {
+            expect(variableSymbol.location.scriptId, endsWith('/foo.dart'));
+          });
+          test('only start token', () async {
+            expect(variableSymbol.location.tokenPos,
+                47 + options.dartLangComment.length);
+            expect(variableSymbol.location.endTokenPos, null);
+          });
+        });
+      });
+      group('global final variable debug symbols', () {
+        TestDriver driver;
+        VariableSymbol variableSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {}
+          final localVariable = A();
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          variableSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('is final', () async {
+          expect(variableSymbol.isFinal, true);
+        });
+      });
+      group('global const variable debug symbols', () {
+        TestDriver driver;
+        VariableSymbol variableSymbol;
+        final source = '''
+          ${options.dartLangComment}
+
+          class A {}
+          const localVariable = A();
+          ''';
+        setUpAll(() async {
+          driver = TestDriver(options, source);
+          var result = await driver.compile();
+          variableSymbol = result.symbols.variables.single;
+        });
+        tearDownAll(() {
+          driver.cleanUp();
+        });
+        test('is const', () async {
+          expect(variableSymbol.isConst, true);
+        });
+      });
+    });
+  }
+}
diff --git a/pkg/nnbd_migration/lib/src/front_end/resources/resources.g.dart b/pkg/nnbd_migration/lib/src/front_end/resources/resources.g.dart
index 411aa65..cedaf06 100644
--- a/pkg/nnbd_migration/lib/src/front_end/resources/resources.g.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/resources/resources.g.dart
@@ -2,6 +2,10 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+// This file is explicitly opted in to null safety since it contains `String?`
+// types, even though the rest of the migration tool isn't migrated yet.
+// @dart=2.12
+
 // This file is generated; don't edit it directly.
 //
 // See pkg/nnbd_migration/tool/codegen/generate_resources.dart for how
@@ -51,7 +55,7 @@
   return String.fromCharCodes(convert.base64Decode(data));
 }
 
-String _MaterialIconsRegular_ttf;
+String? _MaterialIconsRegular_ttf;
 // MaterialIconsRegular_ttf md5 is 'a37b0c01c0baf1888ca812cc0508f6e2'
 String _MaterialIconsRegular_ttf_base64 = '''
 AAEAAAAPAIAAAwBwR0RFRgQAAFMAAYsIAAAAJEdQT1PgGO+cAAGLLAAAADZHU1VC5NKpUQABi2QAAGlQ
@@ -2193,7 +2197,7 @@
 AAAADgAWAAEAGAAkAAoAJgAnABc=
 ''';
 
-String _RobotoMonoRegular_ttf;
+String? _RobotoMonoRegular_ttf;
 // RobotoMonoRegular_ttf md5 is 'b4618f1f7f4cee0ac09873fcc5a966f9'
 String _RobotoMonoRegular_ttf_base64 = '''
 AAEAAAAQAQAABAAAR0RFRgllCWQAAagYAAAAOkdTVULa5NQJAAGoVAAAAkhPUy8yutXqlgABb0AAAABg
@@ -4019,7 +4023,7 @@
 Al4CdwDBA8MDwwDb
 ''';
 
-String _RobotoRegular_ttf;
+String? _RobotoRegular_ttf;
 // RobotoRegular_ttf md5 is '11eabca2251325cfc5589c9c6fb57b46'
 String _RobotoRegular_ttf_base64 = '''
 AAEAAAASAQAABAAgR0RFRrRCsIIAAidIAAACYkdQT1P/GhLXAAIprAAAXcxHU1VC64LkWQACh3gAABWQ
@@ -6879,7 +6883,7 @@
 AAoCPgB6AHMAdAI/AkACQQJCAkMCRAACAAEAFAAdAAA=
 ''';
 
-String _dart_192_png;
+String? _dart_192_png;
 // dart_192_png md5 is '7d80a0adfe72aa9597d5e135b70b42c8'
 String _dart_192_png_base64 = '''
 iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAYAAABS3GwHAAAAAXNSR0IArs4c6QAAAAlwSFlzAAALEwAA
@@ -7035,7 +7039,7 @@
 AAAAAElFTkSuQmCC
 ''';
 
-String _highlight_css;
+String? _highlight_css;
 // highlight_css md5 is 'fb012626bafd286510d32da815dae448'
 String _highlight_css_base64 = '''
 LyoKRGF0ZTogMjQgRmV2IDIwMTUKQXV0aG9yOiBQZWRybyBPbGl2ZWlyYSA8a2FueXR1QGdtYWlsIC4g
@@ -7053,7 +7057,7 @@
 eWxlOiBpdGFsaWM7Cn0KCi5obGpzLXN0cm9uZyB7CiAgZm9udC13ZWlnaHQ6IGJvbGQ7Cn0K
 ''';
 
-String _highlight_pack_js;
+String? _highlight_pack_js;
 // highlight_pack_js md5 is 'e2de0572f5426885d35e366c9bf60f05'
 String _highlight_pack_js_base64 = '''
 LyoKICBIaWdobGlnaHQuanMgMTAuMS4wICg3NGRlNmVhYSkKICBMaWNlbnNlOiBCU0QtMy1DbGF1c2UK
@@ -7421,7 +7425,7 @@
 QFtBLVphLXpdKyJ9LHtiZWdpbjoiPT4ifV19fX0oKSk7
 ''';
 
-String _index_html;
+String? _index_html;
 // index_html md5 is 'c4127573314e7a91769cf9e0bcb489b1'
 String _index_html_base64 = '''
 PGh0bWw+CjxoZWFkPgogICAgPHRpdGxlPk51bGwgU2FmZXR5IFByZXZpZXc8L3RpdGxlPgogICAgPHNj
@@ -7492,7 +7496,7 @@
 PC9zcGFuPjwvZGl2Pgo8L2Zvb3Rlcj4KPC9ib2R5Pgo8L2h0bWw+Cg==
 ''';
 
-String _migration_css;
+String? _migration_css;
 // migration_css md5 is '46b4cc3c93aac35cd6964bf5b91dee2c'
 String _migration_css_base64 = '''
 LyogQ29weXJpZ2h0IChjKSAyMDE5LCB0aGUgRGFydCBwcm9qZWN0IGF1dGhvcnMuIFBsZWFzZSBzZWUg
@@ -7707,7 +7711,7 @@
 anMtbWV0YSB7CiAgY29sb3I6ICM2Mjc5Nzg7Cn0K
 ''';
 
-String _migration_js;
+String? _migration_js;
 // migration_dart md5 is '62f4a5cddf945de898f19cea860ec0b5'
 String _migration_js_base64 = '''
 KGZ1bmN0aW9uIGRhcnRQcm9ncmFtKCl7ZnVuY3Rpb24gY29weVByb3BlcnRpZXMoYSxiKXt2YXIgcz1P
@@ -7738,4120 +7742,4115 @@
 PXMKYVtjXT1mdW5jdGlvbigpe2lmKGFbYl09PT1zKWFbYl09ZCgpCmFbY109ZnVuY3Rpb24oKXtyZXR1
 cm4gdGhpc1tiXX0KcmV0dXJuIGFbYl19fWZ1bmN0aW9uIGxhenlGaW5hbChhLGIsYyxkKXt2YXIgcz1h
 CmFbYl09cwphW2NdPWZ1bmN0aW9uKCl7aWYoYVtiXT09PXMpe3ZhciByPWQoKQppZihhW2JdIT09cylI
-LkJvKGIpCmFbYl09cn1hW2NdPWZ1bmN0aW9uKCl7cmV0dXJuIHRoaXNbYl19CnJldHVybiBhW2JdfX1m
+LkZQKGIpCmFbYl09cn1hW2NdPWZ1bmN0aW9uKCl7cmV0dXJuIHRoaXNbYl19CnJldHVybiBhW2JdfX1m
 dW5jdGlvbiBtYWtlQ29uc3RMaXN0KGEpe2EuaW1tdXRhYmxlJGxpc3Q9QXJyYXkKYS5maXhlZCRsZW5n
 dGg9QXJyYXkKcmV0dXJuIGF9ZnVuY3Rpb24gY29udmVydFRvRmFzdE9iamVjdChhKXtmdW5jdGlvbiB0
 KCl7fXQucHJvdG90eXBlPWEKbmV3IHQoKQpyZXR1cm4gYX1mdW5jdGlvbiBjb252ZXJ0QWxsVG9GYXN0
 T2JqZWN0KGEpe2Zvcih2YXIgcz0wO3M8YS5sZW5ndGg7KytzKWNvbnZlcnRUb0Zhc3RPYmplY3QoYVtz
-XSl9dmFyIHk9MApmdW5jdGlvbiB0ZWFyT2ZmR2V0dGVyKGEsYixjLGQsZSl7cmV0dXJuIGU/bmV3IEZ1
-bmN0aW9uKCJmdW5jcyIsImFwcGx5VHJhbXBvbGluZUluZGV4IiwicmVmbGVjdGlvbkluZm8iLCJuYW1l
-IiwiSCIsImMiLCJyZXR1cm4gZnVuY3Rpb24gdGVhck9mZl8iK2QreSsrKyIocmVjZWl2ZXIpIHsiKyJp
-ZiAoYyA9PT0gbnVsbCkgYyA9ICIrIkguS3EiKyIoIisidGhpcywgZnVuY3MsIGFwcGx5VHJhbXBvbGlu
-ZUluZGV4LCByZWZsZWN0aW9uSW5mbywgZmFsc2UsIHRydWUsIG5hbWUpOyIrInJldHVybiBuZXcgYyh0
-aGlzLCBmdW5jc1swXSwgcmVjZWl2ZXIsIG5hbWUpOyIrIn0iKShhLGIsYyxkLEgsbnVsbCk6bmV3IEZ1
-bmN0aW9uKCJmdW5jcyIsImFwcGx5VHJhbXBvbGluZUluZGV4IiwicmVmbGVjdGlvbkluZm8iLCJuYW1l
-IiwiSCIsImMiLCJyZXR1cm4gZnVuY3Rpb24gdGVhck9mZl8iK2QreSsrKyIoKSB7IisiaWYgKGMgPT09
-IG51bGwpIGMgPSAiKyJILktxIisiKCIrInRoaXMsIGZ1bmNzLCBhcHBseVRyYW1wb2xpbmVJbmRleCwg
-cmVmbGVjdGlvbkluZm8sIGZhbHNlLCBmYWxzZSwgbmFtZSk7IisicmV0dXJuIG5ldyBjKHRoaXMsIGZ1
-bmNzWzBdLCBudWxsLCBuYW1lKTsiKyJ9IikoYSxiLGMsZCxILG51bGwpfWZ1bmN0aW9uIHRlYXJPZmYo
-YSxiLGMsZCxlLGYpe3ZhciBzPW51bGwKcmV0dXJuIGQ/ZnVuY3Rpb24oKXtpZihzPT09bnVsbClzPUgu
-S3EodGhpcyxhLGIsYyx0cnVlLGZhbHNlLGUpLnByb3RvdHlwZQpyZXR1cm4gc306dGVhck9mZkdldHRl
-cihhLGIsYyxlLGYpfXZhciB4PTAKZnVuY3Rpb24gaW5zdGFsbFRlYXJPZmYoYSxiLGMsZCxlLGYsZyxo
-LGksail7dmFyIHM9W10KZm9yKHZhciByPTA7cjxoLmxlbmd0aDtyKyspe3ZhciBxPWhbcl0KaWYodHlw
-ZW9mIHE9PSJzdHJpbmciKXE9YVtxXQpxLiRjYWxsTmFtZT1nW3JdCnMucHVzaChxKX12YXIgcT1zWzBd
-CnEuJFI9ZQpxLiREPWYKdmFyIHA9aQppZih0eXBlb2YgcD09Im51bWJlciIpcCs9eAp2YXIgbz1oWzBd
-CnEuJHN0dWJOYW1lPW8KdmFyIG49dGVhck9mZihzLGp8fDAscCxjLG8sZCkKYVtiXT1uCmlmKGMpcS4k
-dGVhck9mZj1ufWZ1bmN0aW9uIGluc3RhbGxTdGF0aWNUZWFyT2ZmKGEsYixjLGQsZSxmLGcsaCl7cmV0
-dXJuIGluc3RhbGxUZWFyT2ZmKGEsYix0cnVlLGZhbHNlLGMsZCxlLGYsZyxoKX1mdW5jdGlvbiBpbnN0
-YWxsSW5zdGFuY2VUZWFyT2ZmKGEsYixjLGQsZSxmLGcsaCxpKXtyZXR1cm4gaW5zdGFsbFRlYXJPZmYo
-YSxiLGZhbHNlLGMsZCxlLGYsZyxoLGkpfWZ1bmN0aW9uIHNldE9yVXBkYXRlSW50ZXJjZXB0b3JzQnlU
-YWcoYSl7dmFyIHM9di5pbnRlcmNlcHRvcnNCeVRhZwppZighcyl7di5pbnRlcmNlcHRvcnNCeVRhZz1h
-CnJldHVybn1jb3B5UHJvcGVydGllcyhhLHMpfWZ1bmN0aW9uIHNldE9yVXBkYXRlTGVhZlRhZ3MoYSl7
-dmFyIHM9di5sZWFmVGFncwppZighcyl7di5sZWFmVGFncz1hCnJldHVybn1jb3B5UHJvcGVydGllcyhh
-LHMpfWZ1bmN0aW9uIHVwZGF0ZVR5cGVzKGEpe3ZhciBzPXYudHlwZXMKdmFyIHI9cy5sZW5ndGgKcy5w
-dXNoLmFwcGx5KHMsYSkKcmV0dXJuIHJ9ZnVuY3Rpb24gdXBkYXRlSG9sZGVyKGEsYil7Y29weVByb3Bl
-cnRpZXMoYixhKQpyZXR1cm4gYX12YXIgaHVua0hlbHBlcnM9ZnVuY3Rpb24oKXt2YXIgcz1mdW5jdGlv
-bihhLGIsYyxkLGUpe3JldHVybiBmdW5jdGlvbihmLGcsaCxpKXtyZXR1cm4gaW5zdGFsbEluc3RhbmNl
-VGVhck9mZihmLGcsYSxiLGMsZCxbaF0saSxlKX19LHI9ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGZ1
-bmN0aW9uKGUsZixnLGgpe3JldHVybiBpbnN0YWxsU3RhdGljVGVhck9mZihlLGYsYSxiLGMsW2ddLGgs
-ZCl9fQpyZXR1cm57aW5oZXJpdDppbmhlcml0LGluaGVyaXRNYW55OmluaGVyaXRNYW55LG1peGluOm1p
-eGluLGluc3RhbGxTdGF0aWNUZWFyT2ZmOmluc3RhbGxTdGF0aWNUZWFyT2ZmLGluc3RhbGxJbnN0YW5j
-ZVRlYXJPZmY6aW5zdGFsbEluc3RhbmNlVGVhck9mZixfaW5zdGFuY2VfMHU6cygwLDAsbnVsbCxbIiQw
-Il0sMCksX2luc3RhbmNlXzF1OnMoMCwxLG51bGwsWyIkMSJdLDApLF9pbnN0YW5jZV8ydTpzKDAsMixu
-dWxsLFsiJDIiXSwwKSxfaW5zdGFuY2VfMGk6cygxLDAsbnVsbCxbIiQwIl0sMCksX2luc3RhbmNlXzFp
-OnMoMSwxLG51bGwsWyIkMSJdLDApLF9pbnN0YW5jZV8yaTpzKDEsMixudWxsLFsiJDIiXSwwKSxfc3Rh
-dGljXzA6cigwLG51bGwsWyIkMCJdLDApLF9zdGF0aWNfMTpyKDEsbnVsbCxbIiQxIl0sMCksX3N0YXRp
-Y18yOnIoMixudWxsLFsiJDIiXSwwKSxtYWtlQ29uc3RMaXN0Om1ha2VDb25zdExpc3QsbGF6eTpsYXp5
-LGxhenlGaW5hbDpsYXp5RmluYWwsbGF6eU9sZDpsYXp5T2xkLHVwZGF0ZUhvbGRlcjp1cGRhdGVIb2xk
-ZXIsY29udmVydFRvRmFzdE9iamVjdDpjb252ZXJ0VG9GYXN0T2JqZWN0LHNldEZ1bmN0aW9uTmFtZXNJ
-Zk5lY2Vzc2FyeTpzZXRGdW5jdGlvbk5hbWVzSWZOZWNlc3NhcnksdXBkYXRlVHlwZXM6dXBkYXRlVHlw
-ZXMsc2V0T3JVcGRhdGVJbnRlcmNlcHRvcnNCeVRhZzpzZXRPclVwZGF0ZUludGVyY2VwdG9yc0J5VGFn
-LHNldE9yVXBkYXRlTGVhZlRhZ3M6c2V0T3JVcGRhdGVMZWFmVGFnc319KCkKZnVuY3Rpb24gaW5pdGlh
-bGl6ZURlZmVycmVkSHVuayhhKXt4PXYudHlwZXMubGVuZ3RoCmEoaHVua0hlbHBlcnMsdix3LCQpfWZ1
-bmN0aW9uIGdldEdsb2JhbEZyb21OYW1lKGEpe2Zvcih2YXIgcz0wO3M8dy5sZW5ndGg7cysrKXtpZih3
-W3NdPT1DKWNvbnRpbnVlCmlmKHdbc11bYV0pcmV0dXJuIHdbc11bYV19fXZhciBDPXt9LEg9e0ZLOmZ1
-bmN0aW9uIEZLKCl7fSwKR0o6ZnVuY3Rpb24oYSxiLGMpe2lmKGIuQygiYlE8MD4iKS5iKGEpKXJldHVy
-biBuZXcgSC5vbChhLGIuQygiQDwwPiIpLktxKGMpLkMoIm9sPDEsMj4iKSkKcmV0dXJuIG5ldyBILlp5
-KGEsYi5DKCJAPDA+IikuS3EoYykuQygiWnk8MSwyPiIpKX0sCkdROmZ1bmN0aW9uKGEpe3JldHVybiBu
-ZXcgSC5uKCJGaWVsZCAnIithKyInIGhhcyBiZWVuIGFzc2lnbmVkIGR1cmluZyBpbml0aWFsaXphdGlv
-bi4iKX0sCkJpOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5yMyhhKX0sCm9vOmZ1bmN0aW9uKGEpe3Zh
-ciBzLHI9YV40OAppZihyPD05KXJldHVybiByCnM9YXwzMgppZig5Nzw9cyYmczw9MTAyKXJldHVybiBz
-LTg3CnJldHVybi0xfSwKY2I6ZnVuY3Rpb24oYSxiLGMpe2lmKGE9PW51bGwpdGhyb3cgSC5iKG5ldyBI
-LkdNKGIsYy5DKCJHTTwwPiIpKSkKcmV0dXJuIGF9LApxQzpmdW5jdGlvbihhLGIsYyxkKXtQLmsxKGIs
-InN0YXJ0IikKaWYoYyE9bnVsbCl7UC5rMShjLCJlbmQiKQppZihiPmMpSC52KFAuVEUoYiwwLGMsInN0
-YXJ0IixudWxsKSl9cmV0dXJuIG5ldyBILm5IKGEsYixjLGQuQygibkg8MD4iKSl9LApLMTpmdW5jdGlv
-bihhLGIsYyxkKXtpZih0LmQuYihhKSlyZXR1cm4gbmV3IEgueHkoYSxiLGMuQygiQDwwPiIpLktxKGQp
-LkMoInh5PDEsMj4iKSkKcmV0dXJuIG5ldyBILmkxKGEsYixjLkMoIkA8MD4iKS5LcShkKS5DKCJpMTwx
-LDI+IikpfSwKYks6ZnVuY3Rpb24oYSxiLGMpe2lmKHQuZC5iKGEpKXtQLmsxKGIsImNvdW50IikKcmV0
-dXJuIG5ldyBILmQ1KGEsYixjLkMoImQ1PDA+IikpfVAuazEoYiwiY291bnQiKQpyZXR1cm4gbmV3IEgu
-QU0oYSxiLGMuQygiQU08MD4iKSl9LApXcDpmdW5jdGlvbigpe3JldHVybiBuZXcgUC5saigiTm8gZWxl
-bWVudCIpfSwKQW06ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFAubGooIlRvbyBtYW55IGVsZW1lbnRzIil9
-LAphcjpmdW5jdGlvbigpe3JldHVybiBuZXcgUC5saigiVG9vIGZldyBlbGVtZW50cyIpfSwKQlI6ZnVu
-Y3Rpb24gQlIoKXt9LApFNzpmdW5jdGlvbiBFNyhhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApaeTpm
-dW5jdGlvbiBaeShhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApvbDpmdW5jdGlvbiBvbChhLGIpe3Ro
-aXMuYT1hCnRoaXMuJHRpPWJ9LApVcTpmdW5jdGlvbiBVcSgpe30sCmpWOmZ1bmN0aW9uIGpWKGEsYil7
-dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCm46ZnVuY3Rpb24gbihhKXt0aGlzLmE9YX0sCnIzOmZ1bmN0aW9u
-IHIzKGEpe3RoaXMuYT1hfSwKcWo6ZnVuY3Rpb24gcWooYSl7dGhpcy5hPWF9LApHTTpmdW5jdGlvbiBH
-TShhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApiUTpmdW5jdGlvbiBiUSgpe30sCmFMOmZ1bmN0aW9u
-IGFMKCl7fSwKbkg6ZnVuY3Rpb24gbkgoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9
-YwpfLiR0aT1kfSwKYTc6ZnVuY3Rpb24gYTcoYSxiLGMpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5j
-PTAKXy5kPW51bGwKXy4kdGk9Y30sCmkxOmZ1bmN0aW9uIGkxKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9
-Ygp0aGlzLiR0aT1jfSwKeHk6ZnVuY3Rpb24geHkoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMu
-JHRpPWN9LApNSDpmdW5jdGlvbiBNSChhLGIsYyl7dmFyIF89dGhpcwpfLmE9bnVsbApfLmI9YQpfLmM9
-YgpfLiR0aT1jfSwKbEo6ZnVuY3Rpb24gbEooYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuJHRp
-PWN9LApVNTpmdW5jdGlvbiBVNShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy4kdGk9Y30sClNP
-OmZ1bmN0aW9uIFNPKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0aT1jfSwKQU06ZnVuY3Rp
-b24gQU0oYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuJHRpPWN9LApkNTpmdW5jdGlvbiBkNShh
-LGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy4kdGk9Y30sClUxOmZ1bmN0aW9uIFUxKGEsYixjKXt0
-aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0aT1jfSwKTUI6ZnVuY3Rpb24gTUIoYSl7dGhpcy4kdGk9YX0s
-CkZ1OmZ1bmN0aW9uIEZ1KGEpe3RoaXMuJHRpPWF9LAp1NjpmdW5jdGlvbiB1NihhLGIpe3RoaXMuYT1h
-CnRoaXMuJHRpPWJ9LApKQjpmdW5jdGlvbiBKQihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApTVTpm
-dW5jdGlvbiBTVSgpe30sClJlOmZ1bmN0aW9uIFJlKCl7fSwKdzI6ZnVuY3Rpb24gdzIoKXt9LAp3djpm
-dW5jdGlvbiB3dihhKXt0aGlzLmE9YX0sClFDOmZ1bmN0aW9uIFFDKCl7fSwKZGM6ZnVuY3Rpb24oKXt0
-aHJvdyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSB1bm1vZGlmaWFibGUgTWFwIikpfSwKTlE6ZnVuY3Rp
-b24oYSl7dmFyIHMscj1ILkpnKGEpCmlmKHIhPW51bGwpcmV0dXJuIHIKcz0ibWluaWZpZWQ6IithCnJl
-dHVybiBzfSwKd1Y6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihiIT1udWxsKXtzPWIueAppZihzIT1udWxs
-KXJldHVybiBzfXJldHVybiB0LmFVLmIoYSl9LApFajpmdW5jdGlvbihhKXt2YXIgcwppZih0eXBlb2Yg
-YT09InN0cmluZyIpcmV0dXJuIGEKaWYodHlwZW9mIGE9PSJudW1iZXIiKXtpZihhIT09MClyZXR1cm4i
-IithfWVsc2UgaWYoITA9PT1hKXJldHVybiJ0cnVlIgplbHNlIGlmKCExPT09YSlyZXR1cm4iZmFsc2Ui
-CmVsc2UgaWYoYT09bnVsbClyZXR1cm4ibnVsbCIKcz1KLmooYSkKaWYodHlwZW9mIHMhPSJzdHJpbmci
-KXRocm93IEguYihILnRMKGEpKQpyZXR1cm4gc30sCmVROmZ1bmN0aW9uKGEpe3ZhciBzPWEuJGlkZW50
-aXR5SGFzaAppZihzPT1udWxsKXtzPU1hdGgucmFuZG9tKCkqMHgzZmZmZmZmZnwwCmEuJGlkZW50aXR5
-SGFzaD1zfXJldHVybiBzfSwKSHA6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbT1udWxsCmlm
-KHR5cGVvZiBhIT0ic3RyaW5nIilILnYoSC50TChhKSkKcz0vXlxzKlsrLV0/KCgweFthLWYwLTldKyl8
-KFxkKyl8KFthLXowLTldKykpXHMqJC9pLmV4ZWMoYSkKaWYocz09bnVsbClyZXR1cm4gbQppZigzPj1z
-Lmxlbmd0aClyZXR1cm4gSC5PSChzLDMpCnI9c1szXQppZihiPT1udWxsKXtpZihyIT1udWxsKXJldHVy
-biBwYXJzZUludChhLDEwKQppZihzWzJdIT1udWxsKXJldHVybiBwYXJzZUludChhLDE2KQpyZXR1cm4g
-bX1pZihiPDJ8fGI+MzYpdGhyb3cgSC5iKFAuVEUoYiwyLDM2LCJyYWRpeCIsbSkpCmlmKGI9PT0xMCYm
-ciE9bnVsbClyZXR1cm4gcGFyc2VJbnQoYSwxMCkKaWYoYjwxMHx8cj09bnVsbCl7cT1iPD0xMD80Nyti
-Ojg2K2IKcD1zWzFdCmZvcihvPXAubGVuZ3RoLG49MDtuPG87KytuKWlmKChDLnhCLlcocCxuKXwzMik+
-cSlyZXR1cm4gbX1yZXR1cm4gcGFyc2VJbnQoYSxiKX0sCk06ZnVuY3Rpb24oYSl7cmV0dXJuIEguSDUo
-YSl9LApINTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscAppZihhIGluc3RhbmNlb2YgUC5NaClyZXR1cm4g
-SC5kbShILnooYSksbnVsbCkKaWYoSi5pYShhKT09PUMuT2t8fHQuYkouYihhKSl7cz1DLk80KGEpCnI9
-cyE9PSJPYmplY3QiJiZzIT09IiIKaWYocilyZXR1cm4gcwpxPWEuY29uc3RydWN0b3IKaWYodHlwZW9m
-IHE9PSJmdW5jdGlvbiIpe3A9cS5uYW1lCmlmKHR5cGVvZiBwPT0ic3RyaW5nIilyPXAhPT0iT2JqZWN0
-IiYmcCE9PSIiCmVsc2Ugcj0hMQppZihyKXJldHVybiBwfX1yZXR1cm4gSC5kbShILnooYSksbnVsbCl9
-LApNMDpmdW5jdGlvbigpe2lmKCEhc2VsZi5sb2NhdGlvbilyZXR1cm4gc2VsZi5sb2NhdGlvbi5ocmVm
-CnJldHVybiBudWxsfSwKVks6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbz1hLmxlbmd0aAppZihvPD01
-MDApcmV0dXJuIFN0cmluZy5mcm9tQ2hhckNvZGUuYXBwbHkobnVsbCxhKQpmb3Iocz0iIixyPTA7cjxv
-O3I9cSl7cT1yKzUwMApwPXE8bz9xOm8Kcys9U3RyaW5nLmZyb21DaGFyQ29kZS5hcHBseShudWxsLGEu
-c2xpY2UocixwKSl9cmV0dXJuIHN9LApDcTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1ILlZNKFtdLHQu
-YSkKZm9yKHM9YS5sZW5ndGgscj0wO3I8YS5sZW5ndGg7YS5sZW5ndGg9PT1zfHwoMCxILmxrKShhKSwr
-K3Ipe3E9YVtyXQppZighSC5vayhxKSl0aHJvdyBILmIoSC50TChxKSkKaWYocTw9NjU1MzUpQy5ObS5p
-KHAscSkKZWxzZSBpZihxPD0xMTE0MTExKXtDLk5tLmkocCw1NTI5NisoQy5qbi53RyhxLTY1NTM2LDEw
-KSYxMDIzKSkKQy5ObS5pKHAsNTYzMjArKHEmMTAyMykpfWVsc2UgdGhyb3cgSC5iKEgudEwocSkpfXJl
-dHVybiBILlZLKHApfSwKZVQ6ZnVuY3Rpb24oYSl7dmFyIHMscixxCmZvcihzPWEubGVuZ3RoLHI9MDty
-PHM7KytyKXtxPWFbcl0KaWYoIUgub2socSkpdGhyb3cgSC5iKEgudEwocSkpCmlmKHE8MCl0aHJvdyBI
-LmIoSC50TChxKSkKaWYocT42NTUzNSlyZXR1cm4gSC5DcShhKX1yZXR1cm4gSC5WSyhhKX0sCmZ3OmZ1
-bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscAppZihjPD01MDAmJmI9PT0wJiZjPT09YS5sZW5ndGgpcmV0
-dXJuIFN0cmluZy5mcm9tQ2hhckNvZGUuYXBwbHkobnVsbCxhKQpmb3Iocz1iLHI9IiI7czxjO3M9cSl7
-cT1zKzUwMApwPXE8Yz9xOmMKcis9U3RyaW5nLmZyb21DaGFyQ29kZS5hcHBseShudWxsLGEuc3ViYXJy
-YXkocyxwKSl9cmV0dXJuIHJ9LApMdzpmdW5jdGlvbihhKXt2YXIgcwppZigwPD1hKXtpZihhPD02NTUz
-NSlyZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZShhKQppZihhPD0xMTE0MTExKXtzPWEtNjU1MzYKcmV0
-dXJuIFN0cmluZy5mcm9tQ2hhckNvZGUoKEMuam4ud0cocywxMCl8NTUyOTYpPj4+MCxzJjEwMjN8NTYz
-MjApfX10aHJvdyBILmIoUC5URShhLDAsMTExNDExMSxudWxsLG51bGwpKX0sCm8yOmZ1bmN0aW9uKGEp
-e2lmKGEuZGF0ZT09PXZvaWQgMClhLmRhdGU9bmV3IERhdGUoYS5hKQpyZXR1cm4gYS5kYXRlfSwKdEo6
-ZnVuY3Rpb24oYSl7dmFyIHM9SC5vMihhKS5nZXRGdWxsWWVhcigpKzAKcmV0dXJuIHN9LApOUzpmdW5j
-dGlvbihhKXt2YXIgcz1ILm8yKGEpLmdldE1vbnRoKCkrMQpyZXR1cm4gc30sCmpBOmZ1bmN0aW9uKGEp
-e3ZhciBzPUgubzIoYSkuZ2V0RGF0ZSgpKzAKcmV0dXJuIHN9LApJWDpmdW5jdGlvbihhKXt2YXIgcz1I
-Lm8yKGEpLmdldEhvdXJzKCkrMApyZXR1cm4gc30sCmNoOmZ1bmN0aW9uKGEpe3ZhciBzPUgubzIoYSku
-Z2V0TWludXRlcygpKzAKcmV0dXJuIHN9LApKZDpmdW5jdGlvbihhKXt2YXIgcz1ILm8yKGEpLmdldFNl
-Y29uZHMoKSswCnJldHVybiBzfSwKbzE6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vMihhKS5nZXRNaWxsaXNl
-Y29uZHMoKSswCnJldHVybiBzfSwKem86ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscT17fQpxLmE9MApz
-PVtdCnI9W10KcS5hPWIubGVuZ3RoCkMuTm0uRlYocyxiKQpxLmI9IiIKaWYoYyE9bnVsbCYmYy5hIT09
-MCljLksoMCxuZXcgSC5DaihxLHIscykpCiIiK3EuYQpyZXR1cm4gSi5KeShhLG5ldyBILkxJKEMuVGUs
-MCxzLHIsMCkpfSwKRWs6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwCmlmKGIgaW5zdGFuY2VvZiBB
-cnJheSlzPWM9PW51bGx8fGMuYT09PTAKZWxzZSBzPSExCmlmKHMpe3I9YgpxPXIubGVuZ3RoCmlmKHE9
-PT0wKXtpZighIWEuJDApcmV0dXJuIGEuJDAoKX1lbHNlIGlmKHE9PT0xKXtpZighIWEuJDEpcmV0dXJu
-IGEuJDEoclswXSl9ZWxzZSBpZihxPT09Mil7aWYoISFhLiQyKXJldHVybiBhLiQyKHJbMF0sclsxXSl9
-ZWxzZSBpZihxPT09Myl7aWYoISFhLiQzKXJldHVybiBhLiQzKHJbMF0sclsxXSxyWzJdKX1lbHNlIGlm
-KHE9PT00KXtpZighIWEuJDQpcmV0dXJuIGEuJDQoclswXSxyWzFdLHJbMl0sclszXSl9ZWxzZSBpZihx
-PT09NSlpZighIWEuJDUpcmV0dXJuIGEuJDUoclswXSxyWzFdLHJbMl0sclszXSxyWzRdKQpwPWFbIiIr
-IiQiK3FdCmlmKHAhPW51bGwpcmV0dXJuIHAuYXBwbHkoYSxyKX1yZXR1cm4gSC5lMShhLGIsYyl9LApl
-MTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT1iIGluc3RhbmNlb2YgQXJy
-YXk/YjpQLkNIKGIsITAsdC56KSxoPWkubGVuZ3RoLGc9YS4kUgppZihoPGcpcmV0dXJuIEguem8oYSxp
-LGMpCnM9YS4kRApyPXM9PW51bGwKcT0hcj9zKCk6bnVsbApwPUouaWEoYSkKbz1wLiRDCmlmKHR5cGVv
-ZiBvPT0ic3RyaW5nIilvPXBbb10KaWYocil7aWYoYyE9bnVsbCYmYy5hIT09MClyZXR1cm4gSC56byhh
-LGksYykKaWYoaD09PWcpcmV0dXJuIG8uYXBwbHkoYSxpKQpyZXR1cm4gSC56byhhLGksYyl9aWYocSBp
-bnN0YW5jZW9mIEFycmF5KXtpZihjIT1udWxsJiZjLmEhPT0wKXJldHVybiBILnpvKGEsaSxjKQppZiho
-PmcrcS5sZW5ndGgpcmV0dXJuIEguem8oYSxpLG51bGwpCkMuTm0uRlYoaSxxLnNsaWNlKGgtZykpCnJl
-dHVybiBvLmFwcGx5KGEsaSl9ZWxzZXtpZihoPmcpcmV0dXJuIEguem8oYSxpLGMpCm49T2JqZWN0Lmtl
-eXMocSkKaWYoYz09bnVsbClmb3Iocj1uLmxlbmd0aCxtPTA7bTxuLmxlbmd0aDtuLmxlbmd0aD09PXJ8
-fCgwLEgubGspKG4pLCsrbSl7bD1xW0guaChuW21dKV0KaWYoQy5Odj09PWwpcmV0dXJuIEguem8oYSxp
-LGMpCkMuTm0uaShpLGwpfWVsc2V7Zm9yKHI9bi5sZW5ndGgsaz0wLG09MDttPG4ubGVuZ3RoO24ubGVu
-Z3RoPT09cnx8KDAsSC5saykobiksKyttKXtqPUguaChuW21dKQppZihjLng0KGopKXsrK2sKQy5ObS5p
-KGksYy5xKDAsaikpfWVsc2V7bD1xW2pdCmlmKEMuTnY9PT1sKXJldHVybiBILnpvKGEsaSxjKQpDLk5t
-LmkoaSxsKX19aWYoayE9PWMuYSlyZXR1cm4gSC56byhhLGksYyl9cmV0dXJuIG8uYXBwbHkoYSxpKX19
-LApwWTpmdW5jdGlvbihhKXt0aHJvdyBILmIoSC50TChhKSl9LApPSDpmdW5jdGlvbihhLGIpe2lmKGE9
-PW51bGwpSi5IbShhKQp0aHJvdyBILmIoSC5IWShhLGIpKX0sCkhZOmZ1bmN0aW9uKGEsYil7dmFyIHMs
-cixxPSJpbmRleCIKaWYoIUgub2soYikpcmV0dXJuIG5ldyBQLnUoITAsYixxLG51bGwpCnM9SC51UChK
-LkhtKGEpKQppZighKGI8MCkpe2lmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIEgucFkocykKcj1i
-Pj1zfWVsc2Ugcj0hMAppZihyKXJldHVybiBQLkNmKGIsYSxxLG51bGwscykKcmV0dXJuIFAuTzcoYixx
-KX0sCkR1OmZ1bmN0aW9uKGEsYixjKXtpZihhPmMpcmV0dXJuIFAuVEUoYSwwLGMsInN0YXJ0IixudWxs
-KQppZihiIT1udWxsKWlmKGI8YXx8Yj5jKXJldHVybiBQLlRFKGIsYSxjLCJlbmQiLG51bGwpCnJldHVy
-biBuZXcgUC51KCEwLGIsImVuZCIsbnVsbCl9LAp0TDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAudSgh
-MCxhLG51bGwsbnVsbCl9LApiOmZ1bmN0aW9uKGEpe3ZhciBzLHIKaWYoYT09bnVsbClhPW5ldyBQLkYo
-KQpzPW5ldyBFcnJvcigpCnMuZGFydEV4Y2VwdGlvbj1hCnI9SC54CmlmKCJkZWZpbmVQcm9wZXJ0eSIg
-aW4gT2JqZWN0KXtPYmplY3QuZGVmaW5lUHJvcGVydHkocywibWVzc2FnZSIse2dldDpyfSkKcy5uYW1l
-PSIifWVsc2Ugcy50b1N0cmluZz1yCnJldHVybiBzfSwKeDpmdW5jdGlvbigpe3JldHVybiBKLmoodGhp
-cy5kYXJ0RXhjZXB0aW9uKX0sCnY6ZnVuY3Rpb24oYSl7dGhyb3cgSC5iKGEpfSwKbGs6ZnVuY3Rpb24o
-YSl7dGhyb3cgSC5iKFAuYTQoYSkpfSwKY006ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuCmE9SC5l
-QShhLnJlcGxhY2UoU3RyaW5nKHt9KSwiJHJlY2VpdmVyJCIpKQpzPWEubWF0Y2goL1xcXCRbYS16QS1a
-XStcXFwkL2cpCmlmKHM9PW51bGwpcz1ILlZNKFtdLHQucykKcj1zLmluZGV4T2YoIlxcJGFyZ3VtZW50
-c1xcJCIpCnE9cy5pbmRleE9mKCJcXCRhcmd1bWVudHNFeHByXFwkIikKcD1zLmluZGV4T2YoIlxcJGV4
-cHJcXCQiKQpvPXMuaW5kZXhPZigiXFwkbWV0aG9kXFwkIikKbj1zLmluZGV4T2YoIlxcJHJlY2VpdmVy
-XFwkIikKcmV0dXJuIG5ldyBILmY5KGEucmVwbGFjZShuZXcgUmVnRXhwKCJcXFxcXFwkYXJndW1lbnRz
-XFxcXFxcJCIsImciKSwiKCg/Onh8W154XSkqKSIpLnJlcGxhY2UobmV3IFJlZ0V4cCgiXFxcXFxcJGFy
-Z3VtZW50c0V4cHJcXFxcXFwkIiwiZyIpLCIoKD86eHxbXnhdKSopIikucmVwbGFjZShuZXcgUmVnRXhw
-KCJcXFxcXFwkZXhwclxcXFxcXCQiLCJnIiksIigoPzp4fFteeF0pKikiKS5yZXBsYWNlKG5ldyBSZWdF
-eHAoIlxcXFxcXCRtZXRob2RcXFxcXFwkIiwiZyIpLCIoKD86eHxbXnhdKSopIikucmVwbGFjZShuZXcg
-UmVnRXhwKCJcXFxcXFwkcmVjZWl2ZXJcXFxcXFwkIiwiZyIpLCIoKD86eHxbXnhdKSopIikscixxLHAs
-byxuKX0sClM3OmZ1bmN0aW9uKGEpe3JldHVybiBmdW5jdGlvbigkZXhwciQpe3ZhciAkYXJndW1lbnRz
-RXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7JGV4cHIkLiRtZXRob2QkKCRhcmd1bWVudHNFeHByJCl9Y2F0
-Y2gocyl7cmV0dXJuIHMubWVzc2FnZX19KGEpfSwKTWo6ZnVuY3Rpb24oYSl7cmV0dXJuIGZ1bmN0aW9u
-KCRleHByJCl7dHJ5eyRleHByJC4kbWV0aG9kJH1jYXRjaChzKXtyZXR1cm4gcy5tZXNzYWdlfX0oYSl9
-LApUMzpmdW5jdGlvbihhLGIpe3ZhciBzPWI9PW51bGwscj1zP251bGw6Yi5tZXRob2QKcmV0dXJuIG5l
-dyBILmF6KGEscixzP251bGw6Yi5yZWNlaXZlcil9LApSdTpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJl
-dHVybiBuZXcgSC50ZShhKQppZihhIGluc3RhbmNlb2YgSC5icSlyZXR1cm4gSC50VyhhLGEuYSkKaWYo
-dHlwZW9mIGEhPT0ib2JqZWN0IilyZXR1cm4gYQppZigiZGFydEV4Y2VwdGlvbiIgaW4gYSlyZXR1cm4g
-SC50VyhhLGEuZGFydEV4Y2VwdGlvbikKcmV0dXJuIEgudGwoYSl9LAp0VzpmdW5jdGlvbihhLGIpe2lm
-KHQuci5iKGIpKWlmKGIuJHRocm93bkpzRXJyb3I9PW51bGwpYi4kdGhyb3duSnNFcnJvcj1hCnJldHVy
-biBifSwKdGw6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlPW51bGwK
-aWYoISgibWVzc2FnZSIgaW4gYSkpcmV0dXJuIGEKcz1hLm1lc3NhZ2UKaWYoIm51bWJlciIgaW4gYSYm
-dHlwZW9mIGEubnVtYmVyPT0ibnVtYmVyIil7cj1hLm51bWJlcgpxPXImNjU1MzUKaWYoKEMuam4ud0co
-ciwxNikmODE5MSk9PT0xMClzd2l0Y2gocSl7Y2FzZSA0Mzg6cmV0dXJuIEgudFcoYSxILlQzKEguRWoo
-cykrIiAoRXJyb3IgIitxKyIpIixlKSkKY2FzZSA0NDU6Y2FzZSA1MDA3OnA9SC5FaihzKSsiIChFcnJv
-ciAiK3ErIikiCnJldHVybiBILnRXKGEsbmV3IEguVzAocCxlKSl9fWlmKGEgaW5zdGFuY2VvZiBUeXBl
-RXJyb3Ipe289JC5TbigpCm49JC5scSgpCm09JC5OOSgpCmw9JC5pSSgpCms9JC5VTigpCmo9JC5aaCgp
-Cmk9JC5yTigpCiQuYzMoKQpoPSQuSEsoKQpnPSQucjEoKQpmPW8ucVMocykKaWYoZiE9bnVsbClyZXR1
-cm4gSC50VyhhLEguVDMoSC5oKHMpLGYpKQplbHNle2Y9bi5xUyhzKQppZihmIT1udWxsKXtmLm1ldGhv
-ZD0iY2FsbCIKcmV0dXJuIEgudFcoYSxILlQzKEguaChzKSxmKSl9ZWxzZXtmPW0ucVMocykKaWYoZj09
-bnVsbCl7Zj1sLnFTKHMpCmlmKGY9PW51bGwpe2Y9ay5xUyhzKQppZihmPT1udWxsKXtmPWoucVMocykK
-aWYoZj09bnVsbCl7Zj1pLnFTKHMpCmlmKGY9PW51bGwpe2Y9bC5xUyhzKQppZihmPT1udWxsKXtmPWgu
-cVMocykKaWYoZj09bnVsbCl7Zj1nLnFTKHMpCnA9ZiE9bnVsbH1lbHNlIHA9ITB9ZWxzZSBwPSEwfWVs
-c2UgcD0hMH1lbHNlIHA9ITB9ZWxzZSBwPSEwfWVsc2UgcD0hMH1lbHNlIHA9ITAKaWYocCl7SC5oKHMp
-CnJldHVybiBILnRXKGEsbmV3IEguVzAocyxmPT1udWxsP2U6Zi5tZXRob2QpKX19fXJldHVybiBILnRX
-KGEsbmV3IEgudlYodHlwZW9mIHM9PSJzdHJpbmciP3M6IiIpKX1pZihhIGluc3RhbmNlb2YgUmFuZ2VF
-cnJvcil7aWYodHlwZW9mIHM9PSJzdHJpbmciJiZzLmluZGV4T2YoImNhbGwgc3RhY2siKSE9PS0xKXJl
-dHVybiBuZXcgUC5LWSgpCnM9ZnVuY3Rpb24oYil7dHJ5e3JldHVybiBTdHJpbmcoYil9Y2F0Y2goZCl7
-fXJldHVybiBudWxsfShhKQpyZXR1cm4gSC50VyhhLG5ldyBQLnUoITEsZSxlLHR5cGVvZiBzPT0ic3Ry
-aW5nIj9zLnJlcGxhY2UoL15SYW5nZUVycm9yOlxzKi8sIiIpOnMpKX1pZih0eXBlb2YgSW50ZXJuYWxF
-cnJvcj09ImZ1bmN0aW9uIiYmYSBpbnN0YW5jZW9mIEludGVybmFsRXJyb3IpaWYodHlwZW9mIHM9PSJz
-dHJpbmciJiZzPT09InRvbyBtdWNoIHJlY3Vyc2lvbiIpcmV0dXJuIG5ldyBQLktZKCkKcmV0dXJuIGF9
-LAp0czpmdW5jdGlvbihhKXt2YXIgcwppZihhIGluc3RhbmNlb2YgSC5icSlyZXR1cm4gYS5iCmlmKGE9
-PW51bGwpcmV0dXJuIG5ldyBILlhPKGEpCnM9YS4kY2FjaGVkVHJhY2UKaWYocyE9bnVsbClyZXR1cm4g
-cwpyZXR1cm4gYS4kY2FjaGVkVHJhY2U9bmV3IEguWE8oYSl9LApCNzpmdW5jdGlvbihhLGIpe3ZhciBz
-LHIscSxwPWEubGVuZ3RoCmZvcihzPTA7czxwO3M9cSl7cj1zKzEKcT1yKzEKYi5ZNSgwLGFbc10sYVty
-XSl9cmV0dXJuIGJ9LApmdDpmdW5jdGlvbihhLGIsYyxkLGUsZil7dC5ZLmEoYSkKc3dpdGNoKEgudVAo
-Yikpe2Nhc2UgMDpyZXR1cm4gYS4kMCgpCmNhc2UgMTpyZXR1cm4gYS4kMShjKQpjYXNlIDI6cmV0dXJu
-IGEuJDIoYyxkKQpjYXNlIDM6cmV0dXJuIGEuJDMoYyxkLGUpCmNhc2UgNDpyZXR1cm4gYS4kNChjLGQs
-ZSxmKX10aHJvdyBILmIobmV3IFAuQ0QoIlVuc3VwcG9ydGVkIG51bWJlciBvZiBhcmd1bWVudHMgZm9y
-IHdyYXBwZWQgY2xvc3VyZSIpKX0sCnRSOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYT09bnVsbClyZXR1
-cm4gbnVsbApzPWEuJGlkZW50aXR5CmlmKCEhcylyZXR1cm4gcwpzPWZ1bmN0aW9uKGMsZCxlKXtyZXR1
-cm4gZnVuY3Rpb24oZixnLGgsaSl7cmV0dXJuIGUoYyxkLGYsZyxoLGkpfX0oYSxiLEguZnQpCmEuJGlk
-ZW50aXR5PXMKcmV0dXJuIHN9LAppQTpmdW5jdGlvbihhLGIsYyxkLGUsZixnKXt2YXIgcyxyLHEscCxv
-LG4sbSxsPWJbMF0saz1sLiRjYWxsTmFtZSxqPWU/T2JqZWN0LmNyZWF0ZShuZXcgSC56eCgpLmNvbnN0
-cnVjdG9yLnByb3RvdHlwZSk6T2JqZWN0LmNyZWF0ZShuZXcgSC5yVChudWxsLG51bGwsbnVsbCwiIiku
-Y29uc3RydWN0b3IucHJvdG90eXBlKQpqLiRpbml0aWFsaXplPWouY29uc3RydWN0b3IKaWYoZSlzPWZ1
-bmN0aW9uIHN0YXRpY190ZWFyX29mZigpe3RoaXMuJGluaXRpYWxpemUoKX0KZWxzZXtyPSQueWoKaWYo
-dHlwZW9mIHIhPT0ibnVtYmVyIilyZXR1cm4gci5oKCkKJC55aj1yKzEKcj1uZXcgRnVuY3Rpb24oImEs
-YixjLGQiK3IsInRoaXMuJGluaXRpYWxpemUoYSxiLGMsZCIrcisiKSIpCnM9cn1qLmNvbnN0cnVjdG9y
-PXMKcy5wcm90b3R5cGU9agppZighZSl7cT1ILmJ4KGEsbCxmKQpxLiRyZWZsZWN0aW9uSW5mbz1kfWVs
-c2V7ai4kc3RhdGljX25hbWU9ZwpxPWx9ai4kUz1ILmltKGQsZSxmKQpqW2tdPXEKZm9yKHA9cSxvPTE7
-bzxiLmxlbmd0aDsrK28pe249YltvXQptPW4uJGNhbGxOYW1lCmlmKG0hPW51bGwpe249ZT9uOkguYngo
-YSxuLGYpCmpbbV09bn1pZihvPT09Yyl7bi4kcmVmbGVjdGlvbkluZm89ZApwPW59fWouJEM9cApqLiRS
-PWwuJFIKai4kRD1sLiRECnJldHVybiBzfSwKaW06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCmlmKHR5cGVv
-ZiBhPT0ibnVtYmVyIilyZXR1cm4gZnVuY3Rpb24oZCxlKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4g
-ZChlKX19KEguQnAsYSkKaWYodHlwZW9mIGE9PSJzdHJpbmciKXtpZihiKXRocm93IEguYigiQ2Fubm90
-IGNvbXB1dGUgc2lnbmF0dXJlIGZvciBzdGF0aWMgdGVhcm9mZi4iKQpzPWM/SC5QVzpILlRuCnJldHVy
-biBmdW5jdGlvbihkLGUpe3JldHVybiBmdW5jdGlvbigpe3JldHVybiBlKHRoaXMsZCl9fShhLHMpfXRo
-cm93IEguYigiRXJyb3IgaW4gZnVuY3Rpb25UeXBlIG9mIHRlYXJvZmYiKX0sCnZxOmZ1bmN0aW9uKGEs
-YixjLGQpe3ZhciBzPUguRFYKc3dpdGNoKGI/LTE6YSl7Y2FzZSAwOnJldHVybiBmdW5jdGlvbihlLGYp
-e3JldHVybiBmdW5jdGlvbigpe3JldHVybiBmKHRoaXMpW2VdKCl9fShjLHMpCmNhc2UgMTpyZXR1cm4g
-ZnVuY3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oZyl7cmV0dXJuIGYodGhpcylbZV0oZyl9fShjLHMp
-CmNhc2UgMjpyZXR1cm4gZnVuY3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oZyxoKXtyZXR1cm4gZih0
-aGlzKVtlXShnLGgpfX0oYyxzKQpjYXNlIDM6cmV0dXJuIGZ1bmN0aW9uKGUsZil7cmV0dXJuIGZ1bmN0
-aW9uKGcsaCxpKXtyZXR1cm4gZih0aGlzKVtlXShnLGgsaSl9fShjLHMpCmNhc2UgNDpyZXR1cm4gZnVu
-Y3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oZyxoLGksail7cmV0dXJuIGYodGhpcylbZV0oZyxoLGks
-ail9fShjLHMpCmNhc2UgNTpyZXR1cm4gZnVuY3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oZyxoLGks
-aixrKXtyZXR1cm4gZih0aGlzKVtlXShnLGgsaSxqLGspfX0oYyxzKQpkZWZhdWx0OnJldHVybiBmdW5j
-dGlvbihlLGYpe3JldHVybiBmdW5jdGlvbigpe3JldHVybiBlLmFwcGx5KGYodGhpcyksYXJndW1lbnRz
-KX19KGQscyl9fSwKYng6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwLG8sbixtCmlmKGMpcmV0dXJu
-IEguSGYoYSxiKQpzPWIuJHN0dWJOYW1lCnI9Yi5sZW5ndGgKcT1hW3NdCnA9Yj09bnVsbD9xPT1udWxs
-OmI9PT1xCm89IXB8fHI+PTI3CmlmKG8pcmV0dXJuIEgudnEociwhcCxzLGIpCmlmKHI9PT0wKXtwPSQu
-eWoKaWYodHlwZW9mIHAhPT0ibnVtYmVyIilyZXR1cm4gcC5oKCkKJC55aj1wKzEKbj0ic2VsZiIrcApw
-PSJyZXR1cm4gZnVuY3Rpb24oKXt2YXIgIituKyIgPSB0aGlzLiIKbz0kLm1KCnJldHVybiBuZXcgRnVu
-Y3Rpb24ocCsobz09bnVsbD8kLm1KPUguRTIoInNlbGYiKTpvKSsiO3JldHVybiAiK24rIi4iK0guRWoo
-cykrIigpO30iKSgpfW09ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6Ii5zcGxpdCgiIikuc3BsaWNl
-KDAscikuam9pbigiLCIpCnA9JC55agppZih0eXBlb2YgcCE9PSJudW1iZXIiKXJldHVybiBwLmgoKQok
-LnlqPXArMQptKz1wCnA9InJldHVybiBmdW5jdGlvbigiK20rIil7cmV0dXJuIHRoaXMuIgpvPSQubUoK
-cmV0dXJuIG5ldyBGdW5jdGlvbihwKyhvPT1udWxsPyQubUo9SC5FMigic2VsZiIpOm8pKyIuIitILkVq
-KHMpKyIoIittKyIpO30iKSgpfSwKWjQ6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9SC5EVixyPUgueVMK
-c3dpdGNoKGI/LTE6YSl7Y2FzZSAwOnRocm93IEguYihuZXcgSC5FcSgiSW50ZXJjZXB0ZWQgZnVuY3Rp
-b24gd2l0aCBubyBhcmd1bWVudHMuIikpCmNhc2UgMTpyZXR1cm4gZnVuY3Rpb24oZSxmLGcpe3JldHVy
-biBmdW5jdGlvbigpe3JldHVybiBmKHRoaXMpW2VdKGcodGhpcykpfX0oYyxzLHIpCmNhc2UgMjpyZXR1
-cm4gZnVuY3Rpb24oZSxmLGcpe3JldHVybiBmdW5jdGlvbihoKXtyZXR1cm4gZih0aGlzKVtlXShnKHRo
-aXMpLGgpfX0oYyxzLHIpCmNhc2UgMzpyZXR1cm4gZnVuY3Rpb24oZSxmLGcpe3JldHVybiBmdW5jdGlv
-bihoLGkpe3JldHVybiBmKHRoaXMpW2VdKGcodGhpcyksaCxpKX19KGMscyxyKQpjYXNlIDQ6cmV0dXJu
-IGZ1bmN0aW9uKGUsZixnKXtyZXR1cm4gZnVuY3Rpb24oaCxpLGope3JldHVybiBmKHRoaXMpW2VdKGco
-dGhpcyksaCxpLGopfX0oYyxzLHIpCmNhc2UgNTpyZXR1cm4gZnVuY3Rpb24oZSxmLGcpe3JldHVybiBm
-dW5jdGlvbihoLGksaixrKXtyZXR1cm4gZih0aGlzKVtlXShnKHRoaXMpLGgsaSxqLGspfX0oYyxzLHIp
-CmNhc2UgNjpyZXR1cm4gZnVuY3Rpb24oZSxmLGcpe3JldHVybiBmdW5jdGlvbihoLGksaixrLGwpe3Jl
-dHVybiBmKHRoaXMpW2VdKGcodGhpcyksaCxpLGosayxsKX19KGMscyxyKQpkZWZhdWx0OnJldHVybiBm
-dW5jdGlvbihlLGYsZyxoKXtyZXR1cm4gZnVuY3Rpb24oKXtoPVtnKHRoaXMpXQpBcnJheS5wcm90b3R5
-cGUucHVzaC5hcHBseShoLGFyZ3VtZW50cykKcmV0dXJuIGUuYXBwbHkoZih0aGlzKSxoKX19KGQscyxy
-KX19LApIZjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGw9JC5tSgppZihsPT1udWxsKWw9
-JC5tSj1ILkUyKCJzZWxmIikKcz0kLlA0CmlmKHM9PW51bGwpcz0kLlA0PUguRTIoInJlY2VpdmVyIikK
-cj1iLiRzdHViTmFtZQpxPWIubGVuZ3RoCnA9YVtyXQpvPWI9PW51bGw/cD09bnVsbDpiPT09cApuPSFv
-fHxxPj0yOAppZihuKXJldHVybiBILlo0KHEsIW8scixiKQppZihxPT09MSl7bz0icmV0dXJuIGZ1bmN0
-aW9uKCl7cmV0dXJuIHRoaXMuIitsKyIuIitILkVqKHIpKyIodGhpcy4iK3MrIik7IgpuPSQueWoKaWYo
-dHlwZW9mIG4hPT0ibnVtYmVyIilyZXR1cm4gbi5oKCkKJC55aj1uKzEKcmV0dXJuIG5ldyBGdW5jdGlv
-bihvK24rIn0iKSgpfW09ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6Ii5zcGxpdCgiIikuc3BsaWNl
-KDAscS0xKS5qb2luKCIsIikKbz0icmV0dXJuIGZ1bmN0aW9uKCIrbSsiKXtyZXR1cm4gdGhpcy4iK2wr
-Ii4iK0guRWoocikrIih0aGlzLiIrcysiLCAiK20rIik7IgpuPSQueWoKaWYodHlwZW9mIG4hPT0ibnVt
-YmVyIilyZXR1cm4gbi5oKCkKJC55aj1uKzEKcmV0dXJuIG5ldyBGdW5jdGlvbihvK24rIn0iKSgpfSwK
-S3E6ZnVuY3Rpb24oYSxiLGMsZCxlLGYsZyl7cmV0dXJuIEguaUEoYSxiLGMsZCwhIWUsISFmLGcpfSwK
-VG46ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5jRSh2LnR5cGVVbml2ZXJzZSxILnooYS5hKSxiKX0sClBX
-OmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguY0Uodi50eXBlVW5pdmVyc2UsSC56KGEuYyksYil9LApEVjpm
-dW5jdGlvbihhKXtyZXR1cm4gYS5hfSwKeVM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEuY30sCkUyOmZ1bmN0
-aW9uKGEpe3ZhciBzLHIscSxwPW5ldyBILnJUKCJzZWxmIiwidGFyZ2V0IiwicmVjZWl2ZXIiLCJuYW1l
-Iiksbz1KLkVwKE9iamVjdC5nZXRPd25Qcm9wZXJ0eU5hbWVzKHApLHQuVykKZm9yKHM9by5sZW5ndGgs
-cj0wO3I8czsrK3Ipe3E9b1tyXQppZihwW3FdPT09YSlyZXR1cm4gcX10aHJvdyBILmIoUC54WSgiRmll
-bGQgbmFtZSAiK2ErIiBub3QgZm91bmQuIikpfSwKb1Q6ZnVuY3Rpb24oYSl7aWYoYT09bnVsbClILmZP
-KCJib29sZWFuIGV4cHJlc3Npb24gbXVzdCBub3QgYmUgbnVsbCIpCnJldHVybiBhfSwKZk86ZnVuY3Rp
-b24oYSl7dGhyb3cgSC5iKG5ldyBILmtZKGEpKX0sCmFnOmZ1bmN0aW9uKGEpe3Rocm93IEguYihuZXcg
-UC5jKGEpKX0sCllnOmZ1bmN0aW9uKGEpe3JldHVybiB2LmdldElzb2xhdGVUYWcoYSl9LApCbzpmdW5j
-dGlvbihhKXtyZXR1cm4gSC52KG5ldyBILm4oYSkpfSwKaXc6ZnVuY3Rpb24oYSxiLGMpe09iamVjdC5k
-ZWZpbmVQcm9wZXJ0eShhLGIse3ZhbHVlOmMsZW51bWVyYWJsZTpmYWxzZSx3cml0YWJsZTp0cnVlLGNv
-bmZpZ3VyYWJsZTp0cnVlfSl9LAp3MzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG49SC5oKCQuTkYu
-JDEoYSkpLG09JC5ud1tuXQppZihtIT1udWxsKXtPYmplY3QuZGVmaW5lUHJvcGVydHkoYSx2LmRpc3Bh
-dGNoUHJvcGVydHlOYW1lLHt2YWx1ZTptLGVudW1lcmFibGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25m
-aWd1cmFibGU6dHJ1ZX0pCnJldHVybiBtLml9cz0kLnZ2W25dCmlmKHMhPW51bGwpcmV0dXJuIHMKcj12
-LmludGVyY2VwdG9yc0J5VGFnW25dCmlmKHI9PW51bGwpe3E9SC5rKCQuVFguJDIoYSxuKSkKaWYocSE9
-bnVsbCl7bT0kLm53W3FdCmlmKG0hPW51bGwpe09iamVjdC5kZWZpbmVQcm9wZXJ0eShhLHYuZGlzcGF0
-Y2hQcm9wZXJ0eU5hbWUse3ZhbHVlOm0sZW51bWVyYWJsZTpmYWxzZSx3cml0YWJsZTp0cnVlLGNvbmZp
-Z3VyYWJsZTp0cnVlfSkKcmV0dXJuIG0uaX1zPSQudnZbcV0KaWYocyE9bnVsbClyZXR1cm4gcwpyPXYu
-aW50ZXJjZXB0b3JzQnlUYWdbcV0Kbj1xfX1pZihyPT1udWxsKXJldHVybiBudWxsCnM9ci5wcm90b3R5
-cGUKcD1uWzBdCmlmKHA9PT0iISIpe209SC5WYShzKQokLm53W25dPW0KT2JqZWN0LmRlZmluZVByb3Bl
-cnR5KGEsdi5kaXNwYXRjaFByb3BlcnR5TmFtZSx7dmFsdWU6bSxlbnVtZXJhYmxlOmZhbHNlLHdyaXRh
-YmxlOnRydWUsY29uZmlndXJhYmxlOnRydWV9KQpyZXR1cm4gbS5pfWlmKHA9PT0ifiIpeyQudnZbbl09
-cwpyZXR1cm4gc31pZihwPT09Ii0iKXtvPUguVmEocykKT2JqZWN0LmRlZmluZVByb3BlcnR5KE9iamVj
-dC5nZXRQcm90b3R5cGVPZihhKSx2LmRpc3BhdGNoUHJvcGVydHlOYW1lLHt2YWx1ZTpvLGVudW1lcmFi
-bGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25maWd1cmFibGU6dHJ1ZX0pCnJldHVybiBvLml9aWYocD09
-PSIrIilyZXR1cm4gSC5MYyhhLHMpCmlmKHA9PT0iKiIpdGhyb3cgSC5iKFAuU1kobikpCmlmKHYubGVh
-ZlRhZ3Nbbl09PT10cnVlKXtvPUguVmEocykKT2JqZWN0LmRlZmluZVByb3BlcnR5KE9iamVjdC5nZXRQ
-cm90b3R5cGVPZihhKSx2LmRpc3BhdGNoUHJvcGVydHlOYW1lLHt2YWx1ZTpvLGVudW1lcmFibGU6ZmFs
-c2Usd3JpdGFibGU6dHJ1ZSxjb25maWd1cmFibGU6dHJ1ZX0pCnJldHVybiBvLml9ZWxzZSByZXR1cm4g
-SC5MYyhhLHMpfSwKTGM6ZnVuY3Rpb24oYSxiKXt2YXIgcz1PYmplY3QuZ2V0UHJvdG90eXBlT2YoYSkK
-T2JqZWN0LmRlZmluZVByb3BlcnR5KHMsdi5kaXNwYXRjaFByb3BlcnR5TmFtZSx7dmFsdWU6Si5RdShi
-LHMsbnVsbCxudWxsKSxlbnVtZXJhYmxlOmZhbHNlLHdyaXRhYmxlOnRydWUsY29uZmlndXJhYmxlOnRy
-dWV9KQpyZXR1cm4gYn0sClZhOmZ1bmN0aW9uKGEpe3JldHVybiBKLlF1KGEsITEsbnVsbCwhIWEuJGlY
-ail9LApWRjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9Yi5wcm90b3R5cGUKaWYodi5sZWFmVGFnc1thXT09
-PXRydWUpcmV0dXJuIEguVmEocykKZWxzZSByZXR1cm4gSi5RdShzLGMsbnVsbCxudWxsKX0sClhEOmZ1
-bmN0aW9uKCl7aWYoITA9PT0kLkJ2KXJldHVybgokLkJ2PSEwCkguWjEoKX0sCloxOmZ1bmN0aW9uKCl7
-dmFyIHMscixxLHAsbyxuLG0sbAokLm53PU9iamVjdC5jcmVhdGUobnVsbCkKJC52dj1PYmplY3QuY3Jl
-YXRlKG51bGwpCkgua08oKQpzPXYuaW50ZXJjZXB0b3JzQnlUYWcKcj1PYmplY3QuZ2V0T3duUHJvcGVy
-dHlOYW1lcyhzKQppZih0eXBlb2Ygd2luZG93IT0idW5kZWZpbmVkIil7d2luZG93CnE9ZnVuY3Rpb24o
-KXt9CmZvcihwPTA7cDxyLmxlbmd0aDsrK3Ape289cltwXQpuPSQueDcuJDEobykKaWYobiE9bnVsbCl7
-bT1ILlZGKG8sc1tvXSxuKQppZihtIT1udWxsKXtPYmplY3QuZGVmaW5lUHJvcGVydHkobix2LmRpc3Bh
-dGNoUHJvcGVydHlOYW1lLHt2YWx1ZTptLGVudW1lcmFibGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25m
-aWd1cmFibGU6dHJ1ZX0pCnEucHJvdG90eXBlPW59fX19Zm9yKHA9MDtwPHIubGVuZ3RoOysrcCl7bz1y
-W3BdCmlmKC9eW0EtWmEtel9dLy50ZXN0KG8pKXtsPXNbb10Kc1siISIrb109bApzWyJ+IitvXT1sCnNb
-Ii0iK29dPWwKc1siKyIrb109bApzWyIqIitvXT1sfX19LAprTzpmdW5jdGlvbigpe3ZhciBzLHIscSxw
-LG8sbixtPUMuWXEoKQptPUgudWQoQy5LVSxILnVkKEMuZlEsSC51ZChDLmk3LEgudWQoQy5pNyxILnVk
-KEMueGksSC51ZChDLmRrLEgudWQoQy53YihDLk80KSxtKSkpKSkpKQppZih0eXBlb2YgZGFydE5hdGl2
-ZURpc3BhdGNoSG9va3NUcmFuc2Zvcm1lciE9InVuZGVmaW5lZCIpe3M9ZGFydE5hdGl2ZURpc3BhdGNo
-SG9va3NUcmFuc2Zvcm1lcgppZih0eXBlb2Ygcz09ImZ1bmN0aW9uIilzPVtzXQppZihzLmNvbnN0cnVj
-dG9yPT1BcnJheSlmb3Iocj0wO3I8cy5sZW5ndGg7KytyKXtxPXNbcl0KaWYodHlwZW9mIHE9PSJmdW5j
-dGlvbiIpbT1xKG0pfHxtfX1wPW0uZ2V0VGFnCm89bS5nZXRVbmtub3duVGFnCm49bS5wcm90b3R5cGVG
-b3JUYWcKJC5ORj1uZXcgSC5kQyhwKQokLlRYPW5ldyBILndOKG8pCiQueDc9bmV3IEguVlgobil9LAp1
-ZDpmdW5jdGlvbihhLGIpe3JldHVybiBhKGIpfHxifSwKdjQ6ZnVuY3Rpb24oYSxiLGMsZCxlLGYpe3Zh
-ciBzPWI/Im0iOiIiLHI9Yz8iIjoiaSIscT1kPyJ1IjoiIixwPWU/InMiOiIiLG89Zj8iZyI6IiIsbj1m
-dW5jdGlvbihnLGgpe3RyeXtyZXR1cm4gbmV3IFJlZ0V4cChnLGgpfWNhdGNoKG0pe3JldHVybiBtfX0o
-YSxzK3IrcStwK28pCmlmKG4gaW5zdGFuY2VvZiBSZWdFeHApcmV0dXJuIG4KdGhyb3cgSC5iKFAucnIo
-IklsbGVnYWwgUmVnRXhwIHBhdHRlcm4gKCIrU3RyaW5nKG4pKyIpIixhLG51bGwpKX0sClNROmZ1bmN0
-aW9uKGEsYixjKXt2YXIgcwppZih0eXBlb2YgYj09InN0cmluZyIpcmV0dXJuIGEuaW5kZXhPZihiLGMp
-Pj0wCmVsc2UgaWYoYiBpbnN0YW5jZW9mIEguVlIpe3M9Qy54Qi55bihhLGMpCnJldHVybiBiLmIudGVz
-dChzKX1lbHNle3M9Si5GTChiLEMueEIueW4oYSxjKSkKcmV0dXJuIXMuZ2wwKHMpfX0sCkE0OmZ1bmN0
-aW9uKGEpe2lmKGEuaW5kZXhPZigiJCIsMCk+PTApcmV0dXJuIGEucmVwbGFjZSgvXCQvZywiJCQkJCIp
-CnJldHVybiBhfSwKZUE6ZnVuY3Rpb24oYSl7aWYoL1tbXF17fSgpKis/LlxcXiR8XS8udGVzdChhKSly
-ZXR1cm4gYS5yZXBsYWNlKC9bW1xde30oKSorPy5cXF4kfF0vZywiXFwkJiIpCnJldHVybiBhfSwKeXM6
-ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUgubk0oYSxiLGMpCnJldHVybiBzfSwKbk06ZnVuY3Rpb24oYSxi
-LGMpe3ZhciBzLHIscSxwCmlmKGI9PT0iIil7aWYoYT09PSIiKXJldHVybiBjCnM9YS5sZW5ndGgKZm9y
-KHI9YyxxPTA7cTxzOysrcSlyPXIrYVtxXStjCnJldHVybiByLmNoYXJDb2RlQXQoMCk9PTA/cjpyfXA9
-YS5pbmRleE9mKGIsMCkKaWYocDwwKXJldHVybiBhCmlmKGEubGVuZ3RoPDUwMHx8Yy5pbmRleE9mKCIk
-IiwwKT49MClyZXR1cm4gYS5zcGxpdChiKS5qb2luKGMpCnJldHVybiBhLnJlcGxhY2UobmV3IFJlZ0V4
-cChILmVBKGIpLCdnJyksSC5BNChjKSl9LApQRDpmdW5jdGlvbiBQRChhLGIpe3RoaXMuYT1hCnRoaXMu
-JHRpPWJ9LApXVTpmdW5jdGlvbiBXVSgpe30sCkxQOmZ1bmN0aW9uIExQKGEsYixjLGQpe3ZhciBfPXRo
-aXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4kdGk9ZH0sClhSOmZ1bmN0aW9uIFhSKGEsYil7dGhpcy5hPWEK
-dGhpcy4kdGk9Yn0sCkxJOmZ1bmN0aW9uIExJKGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmE9YQpfLmM9
-YgpfLmQ9YwpfLmU9ZApfLmY9ZX0sCkNqOmZ1bmN0aW9uIENqKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9
-Ygp0aGlzLmM9Y30sCmY5OmZ1bmN0aW9uIGY5KGEsYixjLGQsZSxmKXt2YXIgXz10aGlzCl8uYT1hCl8u
-Yj1iCl8uYz1jCl8uZD1kCl8uZT1lCl8uZj1mfSwKVzA6ZnVuY3Rpb24gVzAoYSxiKXt0aGlzLmE9YQp0
-aGlzLmI9Yn0sCmF6OmZ1bmN0aW9uIGF6KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30s
-CnZWOmZ1bmN0aW9uIHZWKGEpe3RoaXMuYT1hfSwKdGU6ZnVuY3Rpb24gdGUoYSl7dGhpcy5hPWF9LApi
-cTpmdW5jdGlvbiBicShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKWE86ZnVuY3Rpb24gWE8oYSl7dGhp
-cy5hPWEKdGhpcy5iPW51bGx9LApUcDpmdW5jdGlvbiBUcCgpe30sCmxjOmZ1bmN0aW9uIGxjKCl7fSwK
-eng6ZnVuY3Rpb24gengoKXt9LApyVDpmdW5jdGlvbiByVChhLGIsYyxkKXt2YXIgXz10aGlzCl8uYT1h
-Cl8uYj1iCl8uYz1jCl8uZD1kfSwKRXE6ZnVuY3Rpb24gRXEoYSl7dGhpcy5hPWF9LAprWTpmdW5jdGlv
-biBrWShhKXt0aGlzLmE9YX0sCmtyOmZ1bmN0aW9uIGtyKCl7fSwKTjU6ZnVuY3Rpb24gTjUoYSl7dmFy
-IF89dGhpcwpfLmE9MApfLmY9Xy5lPV8uZD1fLmM9Xy5iPW51bGwKXy5yPTAKXy4kdGk9YX0sCnZoOmZ1
-bmN0aW9uIHZoKGEsYil7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9Xy5jPW51bGx9LAppNTpmdW5j
-dGlvbiBpNShhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApONjpmdW5jdGlvbiBONihhLGIsYyl7dmFy
-IF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9Xy5jPW51bGwKXy4kdGk9Y30sCmRDOmZ1bmN0aW9uIGRDKGEp
-e3RoaXMuYT1hfSwKd046ZnVuY3Rpb24gd04oYSl7dGhpcy5hPWF9LApWWDpmdW5jdGlvbiBWWChhKXt0
-aGlzLmE9YX0sClZSOmZ1bmN0aW9uIFZSKGEsYil7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9Xy5j
-PW51bGx9LApFSzpmdW5jdGlvbiBFSyhhKXt0aGlzLmI9YX0sCktXOmZ1bmN0aW9uIEtXKGEsYixjKXt0
-aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sClBiOmZ1bmN0aW9uIFBiKGEsYixjKXt2YXIgXz10aGlz
-Cl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1udWxsfSwKdFE6ZnVuY3Rpb24gdFEoYSxiKXt0aGlzLmE9YQp0
-aGlzLmM9Yn0sCnVuOmZ1bmN0aW9uIHVuKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30s
-ClNkOmZ1bmN0aW9uIFNkKGEsYixjKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1udWxs
-fSwKWEY6ZnVuY3Rpb24oYSl7cmV0dXJuIGF9LApvZDpmdW5jdGlvbihhLGIsYyl7aWYoYT4+PjAhPT1h
-fHxhPj1jKXRocm93IEguYihILkhZKGIsYSkpfSwKck06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCmlmKCEo
-YT4+PjAhPT1hKSlzPWI+Pj4wIT09Ynx8YT5ifHxiPmMKZWxzZSBzPSEwCmlmKHMpdGhyb3cgSC5iKEgu
-RHUoYSxiLGMpKQpyZXR1cm4gYn0sCkVUOmZ1bmN0aW9uIEVUKCl7fSwKTFo6ZnVuY3Rpb24gTFooKXt9
-LApEZzpmdW5jdGlvbiBEZygpe30sClBnOmZ1bmN0aW9uIFBnKCl7fSwKeGo6ZnVuY3Rpb24geGooKXt9
-LApkRTpmdW5jdGlvbiBkRSgpe30sClpBOmZ1bmN0aW9uIFpBKCl7fSwKZFQ6ZnVuY3Rpb24gZFQoKXt9
-LApQcTpmdW5jdGlvbiBQcSgpe30sCmVFOmZ1bmN0aW9uIGVFKCl7fSwKVjY6ZnVuY3Rpb24gVjYoKXt9
-LApSRzpmdW5jdGlvbiBSRygpe30sClZQOmZ1bmN0aW9uIFZQKCl7fSwKV0I6ZnVuY3Rpb24gV0IoKXt9
-LApaRzpmdW5jdGlvbiBaRygpe30sCmN6OmZ1bmN0aW9uKGEsYil7dmFyIHM9Yi5jCnJldHVybiBzPT1u
-dWxsP2IuYz1ILkIoYSxiLnosITApOnN9LAp4WjpmdW5jdGlvbihhLGIpe3ZhciBzPWIuYwpyZXR1cm4g
-cz09bnVsbD9iLmM9SC5KKGEsImI4IixbYi56XSk6c30sClExOmZ1bmN0aW9uKGEpe3ZhciBzPWEueQpp
-ZihzPT09Nnx8cz09PTd8fHM9PT04KXJldHVybiBILlExKGEueikKcmV0dXJuIHM9PT0xMXx8cz09PTEy
-fSwKbUQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGEuY3l9LApOMDpmdW5jdGlvbihhKXtyZXR1cm4gSC5FKHYu
-dHlwZVVuaXZlcnNlLGEsITEpfSwKUEw6ZnVuY3Rpb24oYSxiLGEwLGExKXt2YXIgcyxyLHEscCxvLG4s
-bSxsLGssaixpLGgsZyxmLGUsZCxjPWIueQpzd2l0Y2goYyl7Y2FzZSA1OmNhc2UgMTpjYXNlIDI6Y2Fz
-ZSAzOmNhc2UgNDpyZXR1cm4gYgpjYXNlIDY6cz1iLnoKcj1ILlBMKGEscyxhMCxhMSkKaWYocj09PXMp
-cmV0dXJuIGIKcmV0dXJuIEguQyhhLHIsITApCmNhc2UgNzpzPWIuegpyPUguUEwoYSxzLGEwLGExKQpp
-ZihyPT09cylyZXR1cm4gYgpyZXR1cm4gSC5CKGEsciwhMCkKY2FzZSA4OnM9Yi56CnI9SC5QTChhLHMs
-YTAsYTEpCmlmKHI9PT1zKXJldHVybiBiCnJldHVybiBILmYoYSxyLCEwKQpjYXNlIDk6cT1iLlEKcD1I
-LmJaKGEscSxhMCxhMSkKaWYocD09PXEpcmV0dXJuIGIKcmV0dXJuIEguSihhLGIueixwKQpjYXNlIDEw
-Om89Yi56Cm49SC5QTChhLG8sYTAsYTEpCm09Yi5RCmw9SC5iWihhLG0sYTAsYTEpCmlmKG49PT1vJiZs
-PT09bSlyZXR1cm4gYgpyZXR1cm4gSC5hKGEsbixsKQpjYXNlIDExOms9Yi56Cmo9SC5QTChhLGssYTAs
-YTEpCmk9Yi5RCmg9SC5xVChhLGksYTAsYTEpCmlmKGo9PT1rJiZoPT09aSlyZXR1cm4gYgpyZXR1cm4g
-SC5kKGEsaixoKQpjYXNlIDEyOmc9Yi5RCmExKz1nLmxlbmd0aApmPUguYlooYSxnLGEwLGExKQpvPWIu
-egpuPUguUEwoYSxvLGEwLGExKQppZihmPT09ZyYmbj09PW8pcmV0dXJuIGIKcmV0dXJuIEguRChhLG4s
-ZiwhMCkKY2FzZSAxMzplPWIuegppZihlPGExKXJldHVybiBiCmQ9YTBbZS1hMV0KaWYoZD09bnVsbCly
-ZXR1cm4gYgpyZXR1cm4gZApkZWZhdWx0OnRocm93IEguYihQLmhWKCJBdHRlbXB0ZWQgdG8gc3Vic3Rp
-dHV0ZSB1bmV4cGVjdGVkIFJUSSBraW5kICIrYykpfX0sCmJaOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBz
-LHIscSxwLG89Yi5sZW5ndGgsbj1bXQpmb3Iocz0hMSxyPTA7cjxvOysrcil7cT1iW3JdCnA9SC5QTChh
-LHEsYyxkKQppZihwIT09cSlzPSEwCm4ucHVzaChwKX1yZXR1cm4gcz9uOmJ9LAp2TzpmdW5jdGlvbihh
-LGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbT1iLmxlbmd0aCxsPVtdCmZvcihzPSExLHI9MDtyPG07cis9
-Myl7cT1iW3JdCnA9YltyKzFdCm89YltyKzJdCm49SC5QTChhLG8sYyxkKQppZihuIT09bylzPSEwCmwu
-cHVzaChxKQpsLnB1c2gocCkKbC5wdXNoKG4pfXJldHVybiBzP2w6Yn0sCnFUOmZ1bmN0aW9uKGEsYixj
-LGQpe3ZhciBzLHI9Yi5hLHE9SC5iWihhLHIsYyxkKSxwPWIuYixvPUguYlooYSxwLGMsZCksbj1iLmMs
-bT1ILnZPKGEsbixjLGQpCmlmKHE9PT1yJiZvPT09cCYmbT09PW4pcmV0dXJuIGIKcz1uZXcgSC5HKCkK
-cy5hPXEKcy5iPW8Kcy5jPW0KcmV0dXJuIHN9LApWTTpmdW5jdGlvbihhLGIpe2Fbdi5hcnJheVJ0aV09
-YgpyZXR1cm4gYX0sCkpTOmZ1bmN0aW9uKGEpe3ZhciBzPWEuJFMKaWYocyE9bnVsbCl7aWYodHlwZW9m
-IHM9PSJudW1iZXIiKXJldHVybiBILkJwKHMpCnJldHVybiBhLiRTKCl9cmV0dXJuIG51bGx9LApVZTpm
-dW5jdGlvbihhLGIpe3ZhciBzCmlmKEguUTEoYikpaWYoYSBpbnN0YW5jZW9mIEguVHApe3M9SC5KUyhh
-KQppZihzIT1udWxsKXJldHVybiBzfXJldHVybiBILnooYSl9LAp6OmZ1bmN0aW9uKGEpe3ZhciBzCmlm
-KGEgaW5zdGFuY2VvZiBQLk1oKXtzPWEuJHRpCnJldHVybiBzIT1udWxsP3M6SC5WVShhKX1pZihBcnJh
-eS5pc0FycmF5KGEpKXJldHVybiBILnQ2KGEpCnJldHVybiBILlZVKEouaWEoYSkpfSwKdDY6ZnVuY3Rp
-b24oYSl7dmFyIHM9YVt2LmFycmF5UnRpXSxyPXQuYgppZihzPT1udWxsKXJldHVybiByCmlmKHMuY29u
-c3RydWN0b3IhPT1yLmNvbnN0cnVjdG9yKXJldHVybiByCnJldHVybiBzfSwKTGg6ZnVuY3Rpb24oYSl7
-dmFyIHM9YS4kdGkKcmV0dXJuIHMhPW51bGw/czpILlZVKGEpfSwKVlU6ZnVuY3Rpb24oYSl7dmFyIHM9
-YS5jb25zdHJ1Y3RvcixyPXMuJGNjYWNoZQppZihyIT1udWxsKXJldHVybiByCnJldHVybiBILnI5KGEs
-cyl9LApyOTpmdW5jdGlvbihhLGIpe3ZhciBzPWEgaW5zdGFuY2VvZiBILlRwP2EuX19wcm90b19fLl9f
-cHJvdG9fXy5jb25zdHJ1Y3RvcjpiLHI9SC5haSh2LnR5cGVVbml2ZXJzZSxzLm5hbWUpCmIuJGNjYWNo
-ZT1yCnJldHVybiByfSwKQnA6ZnVuY3Rpb24oYSl7dmFyIHMscixxCkgudVAoYSkKcz12LnR5cGVzCnI9
-c1thXQppZih0eXBlb2Ygcj09InN0cmluZyIpe3E9SC5FKHYudHlwZVVuaXZlcnNlLHIsITEpCnNbYV09
-cQpyZXR1cm4gcX1yZXR1cm4gcn0sCkt4OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEueAppZihwIT1u
-dWxsKXJldHVybiBwCnM9YS5jeQpyPXMucmVwbGFjZSgvXCovZywiIikKaWYocj09PXMpcmV0dXJuIGEu
-eD1uZXcgSC5sWShhKQpxPUguRSh2LnR5cGVVbml2ZXJzZSxyLCEwKQpwPXEueApyZXR1cm4gYS54PXA9
-PW51bGw/cS54PW5ldyBILmxZKHEpOnB9LApKSjpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxwPXQu
-SwppZihxPT09cClyZXR1cm4gSC5SRShxLGEsSC5rZSkKaWYoIUguQTgocSkpaWYoIShxPT09dC5fKSlw
-PXE9PT1wCmVsc2UgcD0hMAplbHNlIHA9ITAKaWYocClyZXR1cm4gSC5SRShxLGEsSC5JdykKcD1xLnkK
-cz1wPT09Nj9xLno6cQppZihzPT09dC5TKXI9SC5vawplbHNlIGlmKHM9PT10LmdSfHxzPT09dC5kaSly
-PUguS0gKZWxzZSBpZihzPT09dC5OKXI9SC5NTQplbHNlIHI9cz09PXQueT9ILmw6bnVsbAppZihyIT1u
-dWxsKXJldHVybiBILlJFKHEsYSxyKQppZihzLnk9PT05KXtwPXMuegppZihzLlEuZXZlcnkoSC5jYykp
-e3Eucj0iJGkiK3AKcmV0dXJuIEguUkUocSxhLEgudDQpfX1lbHNlIGlmKHA9PT03KXJldHVybiBILlJF
-KHEsYSxILkFRKQpyZXR1cm4gSC5SRShxLGEsSC5ZTyl9LApSRTpmdW5jdGlvbihhLGIsYyl7YS5iPWMK
-cmV0dXJuIGEuYihiKX0sCkF1OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzCmlmKCFILkE4KHEpKWlm
-KCEocT09PXQuXykpcz1xPT09dC5LCmVsc2Ugcz0hMAplbHNlIHM9ITAKaWYocylyPUguaG4KZWxzZSBp
-ZihxPT09dC5LKXI9SC5UaQplbHNlIHI9SC5sNApxLmE9cgpyZXR1cm4gcS5hKGEpfSwKUWo6ZnVuY3Rp
-b24oYSl7dmFyIHMscj1hLnkKaWYoIUguQTgoYSkpaWYoIShhPT09dC5fKSlpZighKGE9PT10LmNGKSlp
-ZihyIT09NylzPXI9PT04JiZILlFqKGEueil8fGE9PT10LlB8fGE9PT10LlQKZWxzZSBzPSEwCmVsc2Ug
-cz0hMAplbHNlIHM9ITAKZWxzZSBzPSEwCnJldHVybiBzfSwKWU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhp
-cwppZihhPT1udWxsKXJldHVybiBILlFqKHMpCnJldHVybiBILldlKHYudHlwZVVuaXZlcnNlLEguVWUo
-YSxzKSxudWxsLHMsbnVsbCl9LApBUTpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJldHVybiEwCnJldHVy
-biB0aGlzLnouYihhKX0sCnQ0OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcwppZihhPT1udWxsKXJldHVy
-biBILlFqKHIpCnM9ci5yCmlmKGEgaW5zdGFuY2VvZiBQLk1oKXJldHVybiEhYVtzXQpyZXR1cm4hIUou
-aWEoYSlbc119LApPejpmdW5jdGlvbihhKXt2YXIgcz10aGlzCmlmKGE9PW51bGwpcmV0dXJuIGEKZWxz
-ZSBpZihzLmIoYSkpcmV0dXJuIGEKSC5tNChhLHMpfSwKbDQ6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpp
-ZihhPT1udWxsKXJldHVybiBhCmVsc2UgaWYocy5iKGEpKXJldHVybiBhCkgubTQoYSxzKX0sCm00OmZ1
-bmN0aW9uKGEsYil7dGhyb3cgSC5iKEguWmMoSC5XSyhhLEguVWUoYSxiKSxILmRtKGIsbnVsbCkpKSl9
-LApEaDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1udWxsCmlmKEguV2Uodi50eXBlVW5pdmVyc2UsYSxz
-LGIscykpcmV0dXJuIGEKdGhyb3cgSC5iKEguWmMoIlRoZSB0eXBlIGFyZ3VtZW50ICciK0guRWooSC5k
-bShhLHMpKSsiJyBpcyBub3QgYSBzdWJ0eXBlIG9mIHRoZSB0eXBlIHZhcmlhYmxlIGJvdW5kICciK0gu
-RWooSC5kbShiLHMpKSsiJyBvZiB0eXBlIHZhcmlhYmxlICciK0guRWooYykrIicgaW4gJyIrSC5Faihk
-KSsiJy4iKSl9LApXSzpmdW5jdGlvbihhLGIsYyl7dmFyIHM9UC5wKGEpLHI9SC5kbShiPT1udWxsP0gu
-eihhKTpiLG51bGwpCnJldHVybiBzKyI6IHR5cGUgJyIrSC5FaihyKSsiJyBpcyBub3QgYSBzdWJ0eXBl
-IG9mIHR5cGUgJyIrSC5FaihjKSsiJyJ9LApaYzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguaU0oIlR5
-cGVFcnJvcjogIithKX0sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguaU0oIlR5cGVFcnJvcjog
-IitILldLKGEsbnVsbCxiKSl9LAprZTpmdW5jdGlvbihhKXtyZXR1cm4gYSE9bnVsbH0sClRpOmZ1bmN0
-aW9uKGEpe3JldHVybiBhfSwKSXc6ZnVuY3Rpb24oYSl7cmV0dXJuITB9LApobjpmdW5jdGlvbihhKXty
-ZXR1cm4gYX0sCmw6ZnVuY3Rpb24oYSl7cmV0dXJuITA9PT1hfHwhMT09PWF9LApwODpmdW5jdGlvbihh
-KXtpZighMD09PWEpcmV0dXJuITAKaWYoITE9PT1hKXJldHVybiExCnRocm93IEguYihILnEoYSwiYm9v
-bCIpKX0sCnk4OmZ1bmN0aW9uKGEpe2lmKCEwPT09YSlyZXR1cm4hMAppZighMT09PWEpcmV0dXJuITEK
-aWYoYT09bnVsbClyZXR1cm4gYQp0aHJvdyBILmIoSC5xKGEsImJvb2wiKSl9LApkcDpmdW5jdGlvbihh
-KXtpZighMD09PWEpcmV0dXJuITAKaWYoITE9PT1hKXJldHVybiExCmlmKGE9PW51bGwpcmV0dXJuIGEK
-dGhyb3cgSC5iKEgucShhLCJib29sPyIpKX0sCkZHOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVt
-YmVyIilyZXR1cm4gYQp0aHJvdyBILmIoSC5xKGEsImRvdWJsZSIpKX0sCkdIOmZ1bmN0aW9uKGEpe2lm
-KHR5cGVvZiBhPT0ibnVtYmVyIilyZXR1cm4gYQppZihhPT1udWxsKXJldHVybiBhCnRocm93IEguYihI
-LnEoYSwiZG91YmxlIikpfSwKUWs6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiKXJldHVy
-biBhCmlmKGE9PW51bGwpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJkb3VibGU/IikpfSwKb2s6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIHR5cGVvZiBhPT0ibnVtYmVyIiYmTWF0aC5mbG9vcihhKT09PWF9LApJWjpm
-dW5jdGlvbihhKXtpZih0eXBlb2YgYT09Im51bWJlciImJk1hdGguZmxvb3IoYSk9PT1hKXJldHVybiBh
-CnRocm93IEguYihILnEoYSwiaW50IikpfSwKdVA6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1i
-ZXIiJiZNYXRoLmZsb29yKGEpPT09YSlyZXR1cm4gYQppZihhPT1udWxsKXJldHVybiBhCnRocm93IEgu
-YihILnEoYSwiaW50IikpfSwKVWM6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiJiZNYXRo
-LmZsb29yKGEpPT09YSlyZXR1cm4gYQppZihhPT1udWxsKXJldHVybiBhCnRocm93IEguYihILnEoYSwi
-aW50PyIpKX0sCktIOmZ1bmN0aW9uKGEpe3JldHVybiB0eXBlb2YgYT09Im51bWJlciJ9LAp6NTpmdW5j
-dGlvbihhKXtpZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJudW0i
-KSl9LApXMTpmdW5jdGlvbihhKXtpZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKaWYoYT09bnVs
-bClyZXR1cm4gYQp0aHJvdyBILmIoSC5xKGEsIm51bSIpKX0sCmNVOmZ1bmN0aW9uKGEpe2lmKHR5cGVv
-ZiBhPT0ibnVtYmVyIilyZXR1cm4gYQppZihhPT1udWxsKXJldHVybiBhCnRocm93IEguYihILnEoYSwi
-bnVtPyIpKX0sCk1NOmZ1bmN0aW9uKGEpe3JldHVybiB0eXBlb2YgYT09InN0cmluZyJ9LApCdDpmdW5j
-dGlvbihhKXtpZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJTdHJp
-bmciKSl9LApoOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ic3RyaW5nIilyZXR1cm4gYQppZihhPT1u
-dWxsKXJldHVybiBhCnRocm93IEguYihILnEoYSwiU3RyaW5nIikpfSwKazpmdW5jdGlvbihhKXtpZih0
-eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIGEKaWYoYT09bnVsbClyZXR1cm4gYQp0aHJvdyBILmIoSC5x
-KGEsIlN0cmluZz8iKSl9LAppbzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpmb3Iocz0iIixyPSIiLHE9
-MDtxPGEubGVuZ3RoOysrcSxyPSIsICIpcys9Qy54Qi5oKHIsSC5kbShhW3FdLGIpKQpyZXR1cm4gc30s
-CmJJOmZ1bmN0aW9uKGE1LGE2LGE3KXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxj
-LGIsYSxhMCxhMSxhMixhMyxhND0iLCAiCmlmKGE3IT1udWxsKXtzPWE3Lmxlbmd0aAppZihhNj09bnVs
-bCl7YTY9SC5WTShbXSx0LnMpCnI9bnVsbH1lbHNlIHI9YTYubGVuZ3RoCnE9YTYubGVuZ3RoCmZvcihw
-PXM7cD4wOy0tcClDLk5tLmkoYTYsIlQiKyhxK3ApKQpmb3Iobz10Llcsbj10Ll8sbT10LkssbD0iPCIs
-az0iIixwPTA7cDxzOysrcCxrPWE0KXtsKz1rCmo9YTYubGVuZ3RoCmk9ai0xLXAKaWYoaTwwKXJldHVy
-biBILk9IKGE2LGkpCmw9Qy54Qi5oKGwsYTZbaV0pCmg9YTdbcF0KZz1oLnkKaWYoIShnPT09Mnx8Zz09
-PTN8fGc9PT00fHxnPT09NXx8aD09PW8pKWlmKCEoaD09PW4pKWo9aD09PW0KZWxzZSBqPSEwCmVsc2Ug
-aj0hMAppZighailsKz1DLnhCLmgoIiBleHRlbmRzICIsSC5kbShoLGE2KSl9bCs9Ij4ifWVsc2V7bD0i
-IgpyPW51bGx9bz1hNS56CmY9YTUuUQplPWYuYQpkPWUubGVuZ3RoCmM9Zi5iCmI9Yy5sZW5ndGgKYT1m
-LmMKYTA9YS5sZW5ndGgKYTE9SC5kbShvLGE2KQpmb3IoYTI9IiIsYTM9IiIscD0wO3A8ZDsrK3AsYTM9
-YTQpYTIrPUMueEIuaChhMyxILmRtKGVbcF0sYTYpKQppZihiPjApe2EyKz1hMysiWyIKZm9yKGEzPSIi
-LHA9MDtwPGI7KytwLGEzPWE0KWEyKz1DLnhCLmgoYTMsSC5kbShjW3BdLGE2KSkKYTIrPSJdIn1pZihh
-MD4wKXthMis9YTMrInsiCmZvcihhMz0iIixwPTA7cDxhMDtwKz0zLGEzPWE0KXthMis9YTMKaWYoYVtw
-KzFdKWEyKz0icmVxdWlyZWQgIgphMis9Si5iYihILmRtKGFbcCsyXSxhNiksIiAiKSthW3BdfWEyKz0i
-fSJ9aWYociE9bnVsbCl7YTYudG9TdHJpbmcKYTYubGVuZ3RoPXJ9cmV0dXJuIGwrIigiK2EyKyIpID0+
-ICIrSC5FaihhMSl9LApkbTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGw9YS55CmlmKGw9
-PT01KXJldHVybiJlcmFzZWQiCmlmKGw9PT0yKXJldHVybiJkeW5hbWljIgppZihsPT09MylyZXR1cm4i
-dm9pZCIKaWYobD09PTEpcmV0dXJuIk5ldmVyIgppZihsPT09NClyZXR1cm4iYW55IgppZihsPT09Nil7
-cz1ILmRtKGEueixiKQpyZXR1cm4gc31pZihsPT09Nyl7cj1hLnoKcz1ILmRtKHIsYikKcT1yLnkKcmV0
-dXJuIEouYmIocT09PTExfHxxPT09MTI/Qy54Qi5oKCIoIixzKSsiKSI6cywiPyIpfWlmKGw9PT04KXJl
-dHVybiJGdXR1cmVPcjwiK0guRWooSC5kbShhLnosYikpKyI+IgppZihsPT09OSl7cD1ILm8zKGEueikK
-bz1hLlEKcmV0dXJuIG8ubGVuZ3RoIT09MD9wKygiPCIrSC5pbyhvLGIpKyI+Iik6cH1pZihsPT09MTEp
-cmV0dXJuIEguYkkoYSxiLG51bGwpCmlmKGw9PT0xMilyZXR1cm4gSC5iSShhLnosYixhLlEpCmlmKGw9
-PT0xMyl7Yi50b1N0cmluZwpuPWEuegptPWIubGVuZ3RoCm49bS0xLW4KaWYobjwwfHxuPj1tKXJldHVy
-biBILk9IKGIsbikKcmV0dXJuIGJbbl19cmV0dXJuIj8ifSwKbzM6ZnVuY3Rpb24oYSl7dmFyIHMscj1I
-LkpnKGEpCmlmKHIhPW51bGwpcmV0dXJuIHIKcz0ibWluaWZpZWQ6IithCnJldHVybiBzfSwKUW86ZnVu
-Y3Rpb24oYSxiKXt2YXIgcz1hLnRSW2JdCmZvcig7dHlwZW9mIHM9PSJzdHJpbmciOylzPWEudFJbc10K
-cmV0dXJuIHN9LAphaTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj1hLmVULG09bltiXQppZiht
-PT1udWxsKXJldHVybiBILkUoYSxiLCExKQplbHNlIGlmKHR5cGVvZiBtPT0ibnVtYmVyIil7cz1tCnI9
-SC5tKGEsNSwiIyIpCnE9W10KZm9yKHA9MDtwPHM7KytwKXEucHVzaChyKQpvPUguSihhLGIscSkKblti
-XT1vCnJldHVybiBvfWVsc2UgcmV0dXJuIG19LAp4YjpmdW5jdGlvbihhLGIpe3JldHVybiBILkl4KGEu
-dFIsYil9LApGRjpmdW5jdGlvbihhLGIpe3JldHVybiBILkl4KGEuZVQsYil9LApFOmZ1bmN0aW9uKGEs
-YixjKXt2YXIgcyxyPWEuZUMscT1yLmdldChiKQppZihxIT1udWxsKXJldHVybiBxCnM9SC5pKEgubyhh
-LG51bGwsYixjKSkKci5zZXQoYixzKQpyZXR1cm4gc30sCmNFOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxy
-LHE9Yi5jaAppZihxPT1udWxsKXE9Yi5jaD1uZXcgTWFwKCkKcz1xLmdldChjKQppZihzIT1udWxsKXJl
-dHVybiBzCnI9SC5pKEgubyhhLGIsYywhMCkpCnEuc2V0KGMscikKcmV0dXJuIHJ9LAp2NTpmdW5jdGlv
-bihhLGIsYyl7dmFyIHMscixxLHA9Yi5jeAppZihwPT1udWxsKXA9Yi5jeD1uZXcgTWFwKCkKcz1jLmN5
-CnI9cC5nZXQocykKaWYociE9bnVsbClyZXR1cm4gcgpxPUguYShhLGIsYy55PT09MTA/Yy5ROltjXSkK
-cC5zZXQocyxxKQpyZXR1cm4gcX0sCkJEOmZ1bmN0aW9uKGEsYil7Yi5hPUguQXUKYi5iPUguSkoKcmV0
-dXJuIGJ9LAptOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHE9YS5lQy5nZXQoYykKaWYocSE9bnVsbCly
-ZXR1cm4gcQpzPW5ldyBILkpjKG51bGwsbnVsbCkKcy55PWIKcy5jeT1jCnI9SC5CRChhLHMpCmEuZUMu
-c2V0KGMscikKcmV0dXJuIHJ9LApDOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPWIuY3krIioiLHE9YS5l
-Qy5nZXQocikKaWYocSE9bnVsbClyZXR1cm4gcQpzPUguWjcoYSxiLHIsYykKYS5lQy5zZXQocixzKQpy
-ZXR1cm4gc30sClo3OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQppZihkKXtzPWIueQppZighSC5B
-OChiKSlyPWI9PT10LlB8fGI9PT10LlR8fHM9PT03fHxzPT09NgplbHNlIHI9ITAKaWYocilyZXR1cm4g
-Yn1xPW5ldyBILkpjKG51bGwsbnVsbCkKcS55PTYKcS56PWIKcS5jeT1jCnJldHVybiBILkJEKGEscSl9
-LApCOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPWIuY3krIj8iLHE9YS5lQy5nZXQocikKaWYocSE9bnVs
-bClyZXR1cm4gcQpzPUgubGwoYSxiLHIsYykKYS5lQy5zZXQocixzKQpyZXR1cm4gc30sCmxsOmZ1bmN0
-aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwCmlmKGQpe3M9Yi55CmlmKCFILkE4KGIpKWlmKCEoYj09PXQu
-UHx8Yj09PXQuVCkpaWYocyE9PTcpcj1zPT09OCYmSC5sUihiLnopCmVsc2Ugcj0hMAplbHNlIHI9ITAK
-ZWxzZSByPSEwCmlmKHIpcmV0dXJuIGIKZWxzZSBpZihzPT09MXx8Yj09PXQuY0YpcmV0dXJuIHQuUApl
-bHNlIGlmKHM9PT02KXtxPWIuegppZihxLnk9PT04JiZILmxSKHEueikpcmV0dXJuIHEKZWxzZSByZXR1
-cm4gSC5jeihhLGIpfX1wPW5ldyBILkpjKG51bGwsbnVsbCkKcC55PTcKcC56PWIKcC5jeT1jCnJldHVy
-biBILkJEKGEscCl9LApmOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPWIuY3krIi8iLHE9YS5lQy5nZXQo
-cikKaWYocSE9bnVsbClyZXR1cm4gcQpzPUguZVYoYSxiLHIsYykKYS5lQy5zZXQocixzKQpyZXR1cm4g
-c30sCmVWOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQppZihkKXtzPWIueQppZighSC5BOChiKSlp
-ZighKGI9PT10Ll8pKXI9Yj09PXQuSwplbHNlIHI9ITAKZWxzZSByPSEwCmlmKHJ8fGI9PT10LkspcmV0
-dXJuIGIKZWxzZSBpZihzPT09MSlyZXR1cm4gSC5KKGEsImI4IixbYl0pCmVsc2UgaWYoYj09PXQuUHx8
-Yj09PXQuVClyZXR1cm4gdC5iR31xPW5ldyBILkpjKG51bGwsbnVsbCkKcS55PTgKcS56PWIKcS5jeT1j
-CnJldHVybiBILkJEKGEscSl9LApIOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPSIiK2IrIl4iLHA9YS5l
-Qy5nZXQocSkKaWYocCE9bnVsbClyZXR1cm4gcApzPW5ldyBILkpjKG51bGwsbnVsbCkKcy55PTEzCnMu
-ej1iCnMuY3k9cQpyPUguQkQoYSxzKQphLmVDLnNldChxLHIpCnJldHVybiByfSwKVXg6ZnVuY3Rpb24o
-YSl7dmFyIHMscixxLHA9YS5sZW5ndGgKZm9yKHM9IiIscj0iIixxPTA7cTxwOysrcSxyPSIsIilzKz1y
-K2FbcV0uY3kKcmV0dXJuIHN9LApTNDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbT1hLmxlbmd0
-aApmb3Iocz0iIixyPSIiLHE9MDtxPG07cSs9MyxyPSIsIil7cD1hW3FdCm89YVtxKzFdPyIhIjoiOiIK
-bj1hW3ErMl0uY3kKcys9citwK28rbn1yZXR1cm4gc30sCko6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIs
-cSxwPWIKaWYoYy5sZW5ndGghPT0wKXArPSI8IitILlV4KGMpKyI+IgpzPWEuZUMuZ2V0KHApCmlmKHMh
-PW51bGwpcmV0dXJuIHMKcj1uZXcgSC5KYyhudWxsLG51bGwpCnIueT05CnIuej1iCnIuUT1jCmlmKGMu
-bGVuZ3RoPjApci5jPWNbMF0Kci5jeT1wCnE9SC5CRChhLHIpCmEuZUMuc2V0KHAscSkKcmV0dXJuIHF9
-LAphOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4KaWYoYi55PT09MTApe3M9Yi56CnI9Yi5R
-LmNvbmNhdChjKX1lbHNle3I9YwpzPWJ9cT1zLmN5KygiOzwiK0guVXgocikrIj4iKQpwPWEuZUMuZ2V0
-KHEpCmlmKHAhPW51bGwpcmV0dXJuIHAKbz1uZXcgSC5KYyhudWxsLG51bGwpCm8ueT0xMApvLno9cwpv
-LlE9cgpvLmN5PXEKbj1ILkJEKGEsbykKYS5lQy5zZXQocSxuKQpyZXR1cm4gbn0sCmQ6ZnVuY3Rpb24o
-YSxiLGMpe3ZhciBzLHIscSxwLG8sbj1iLmN5LG09Yy5hLGw9bS5sZW5ndGgsaz1jLmIsaj1rLmxlbmd0
-aCxpPWMuYyxoPWkubGVuZ3RoLGc9IigiK0guVXgobSkKaWYoaj4wKXtzPWw+MD8iLCI6IiIKcj1ILlV4
-KGspCmcrPXMrIlsiK3IrIl0ifWlmKGg+MCl7cz1sPjA/IiwiOiIiCnI9SC5TNChpKQpnKz1zKyJ7Iity
-KyJ9In1xPW4rKGcrIikiKQpwPWEuZUMuZ2V0KHEpCmlmKHAhPW51bGwpcmV0dXJuIHAKbz1uZXcgSC5K
-YyhudWxsLG51bGwpCm8ueT0xMQpvLno9YgpvLlE9YwpvLmN5PXEKcj1ILkJEKGEsbykKYS5lQy5zZXQo
-cSxyKQpyZXR1cm4gcn0sCkQ6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscj1iLmN5KygiPCIrSC5VeChj
-KSsiPiIpLHE9YS5lQy5nZXQocikKaWYocSE9bnVsbClyZXR1cm4gcQpzPUguaHcoYSxiLGMscixkKQph
-LmVDLnNldChyLHMpCnJldHVybiBzfSwKaHc6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxv
-LG4sbSxsCmlmKGUpe3M9Yy5sZW5ndGgKcj1uZXcgQXJyYXkocykKZm9yKHE9MCxwPTA7cDxzOysrcCl7
-bz1jW3BdCmlmKG8ueT09PTEpe3JbcF09bzsrK3F9fWlmKHE+MCl7bj1ILlBMKGEsYixyLDApCm09SC5i
-WihhLGMsciwwKQpyZXR1cm4gSC5EKGEsbixtLGMhPT1tKX19bD1uZXcgSC5KYyhudWxsLG51bGwpCmwu
-eT0xMgpsLno9YgpsLlE9YwpsLmN5PWQKcmV0dXJuIEguQkQoYSxsKX0sCm86ZnVuY3Rpb24oYSxiLGMs
-ZCl7cmV0dXJue3U6YSxlOmIscjpjLHM6W10scDowLG46ZH19LAppOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cSxwLG8sbixtLGwsayxqLGksaCxnPWEucixmPWEucwpmb3Iocz1nLmxlbmd0aCxyPTA7cjxzOyl7cT1n
-LmNoYXJDb2RlQXQocikKaWYocT49NDgmJnE8PTU3KXI9SC5BKHIrMSxxLGcsZikKZWxzZSBpZigoKChx
-fDMyKT4+PjApLTk3JjY1NTM1KTwyNnx8cT09PTk1fHxxPT09MzYpcj1ILnQoYSxyLGcsZiwhMSkKZWxz
-ZSBpZihxPT09NDYpcj1ILnQoYSxyLGcsZiwhMCkKZWxzZXsrK3IKc3dpdGNoKHEpe2Nhc2UgNDQ6YnJl
-YWsKY2FzZSA1ODpmLnB1c2goITEpCmJyZWFrCmNhc2UgMzM6Zi5wdXNoKCEwKQpicmVhawpjYXNlIDU5
-OmYucHVzaChILksoYS51LGEuZSxmLnBvcCgpKSkKYnJlYWsKY2FzZSA5NDpmLnB1c2goSC5IKGEudSxm
-LnBvcCgpKSkKYnJlYWsKY2FzZSAzNTpmLnB1c2goSC5tKGEudSw1LCIjIikpCmJyZWFrCmNhc2UgNjQ6
-Zi5wdXNoKEgubShhLnUsMiwiQCIpKQpicmVhawpjYXNlIDEyNjpmLnB1c2goSC5tKGEudSwzLCJ+Iikp
-CmJyZWFrCmNhc2UgNjA6Zi5wdXNoKGEucCkKYS5wPWYubGVuZ3RoCmJyZWFrCmNhc2UgNjI6cD1hLnUK
-bz1mLnNwbGljZShhLnApCkgucihhLnUsYS5lLG8pCmEucD1mLnBvcCgpCm49Zi5wb3AoKQppZih0eXBl
-b2Ygbj09InN0cmluZyIpZi5wdXNoKEguSihwLG4sbykpCmVsc2V7bT1ILksocCxhLmUsbikKc3dpdGNo
-KG0ueSl7Y2FzZSAxMTpmLnB1c2goSC5EKHAsbSxvLGEubikpCmJyZWFrCmRlZmF1bHQ6Zi5wdXNoKEgu
-YShwLG0sbykpCmJyZWFrfX1icmVhawpjYXNlIDM4OkguSShhLGYpCmJyZWFrCmNhc2UgNDI6bD1hLnUK
-Zi5wdXNoKEguQyhsLEguSyhsLGEuZSxmLnBvcCgpKSxhLm4pKQpicmVhawpjYXNlIDYzOmw9YS51CmYu
-cHVzaChILkIobCxILksobCxhLmUsZi5wb3AoKSksYS5uKSkKYnJlYWsKY2FzZSA0NzpsPWEudQpmLnB1
-c2goSC5mKGwsSC5LKGwsYS5lLGYucG9wKCkpLGEubikpCmJyZWFrCmNhc2UgNDA6Zi5wdXNoKGEucCkK
-YS5wPWYubGVuZ3RoCmJyZWFrCmNhc2UgNDE6cD1hLnUKaz1uZXcgSC5HKCkKaj1wLnNFQQppPXAuc0VB
-Cm49Zi5wb3AoKQppZih0eXBlb2Ygbj09Im51bWJlciIpc3dpdGNoKG4pe2Nhc2UtMTpqPWYucG9wKCkK
-YnJlYWsKY2FzZS0yOmk9Zi5wb3AoKQpicmVhawpkZWZhdWx0OmYucHVzaChuKQpicmVha31lbHNlIGYu
-cHVzaChuKQpvPWYuc3BsaWNlKGEucCkKSC5yKGEudSxhLmUsbykKYS5wPWYucG9wKCkKay5hPW8Kay5i
-PWoKay5jPWkKZi5wdXNoKEguZChwLEguSyhwLGEuZSxmLnBvcCgpKSxrKSkKYnJlYWsKY2FzZSA5MTpm
-LnB1c2goYS5wKQphLnA9Zi5sZW5ndGgKYnJlYWsKY2FzZSA5MzpvPWYuc3BsaWNlKGEucCkKSC5yKGEu
-dSxhLmUsbykKYS5wPWYucG9wKCkKZi5wdXNoKG8pCmYucHVzaCgtMSkKYnJlYWsKY2FzZSAxMjM6Zi5w
-dXNoKGEucCkKYS5wPWYubGVuZ3RoCmJyZWFrCmNhc2UgMTI1Om89Zi5zcGxpY2UoYS5wKQpILnkoYS51
-LGEuZSxvKQphLnA9Zi5wb3AoKQpmLnB1c2gobykKZi5wdXNoKC0yKQpicmVhawpkZWZhdWx0OnRocm93
-IkJhZCBjaGFyYWN0ZXIgIitxfX19aD1mLnBvcCgpCnJldHVybiBILksoYS51LGEuZSxoKX0sCkE6ZnVu
-Y3Rpb24oYSxiLGMsZCl7dmFyIHMscixxPWItNDgKZm9yKHM9Yy5sZW5ndGg7YTxzOysrYSl7cj1jLmNo
-YXJDb2RlQXQoYSkKaWYoIShyPj00OCYmcjw9NTcpKWJyZWFrCnE9cSoxMCsoci00OCl9ZC5wdXNoKHEp
-CnJldHVybiBhfSwKdDpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8sbixtPWIrMQpmb3Io
-cz1jLmxlbmd0aDttPHM7KyttKXtyPWMuY2hhckNvZGVBdChtKQppZihyPT09NDYpe2lmKGUpYnJlYWsK
-ZT0hMH1lbHNle2lmKCEoKCgocnwzMik+Pj4wKS05NyY2NTUzNSk8MjZ8fHI9PT05NXx8cj09PTM2KSlx
-PXI+PTQ4JiZyPD01NwplbHNlIHE9ITAKaWYoIXEpYnJlYWt9fXA9Yy5zdWJzdHJpbmcoYixtKQppZihl
-KXtzPWEudQpvPWEuZQppZihvLnk9PT0xMClvPW8uegpuPUguUW8ocyxvLnopW3BdCmlmKG49PW51bGwp
-SC52KCdObyAiJytwKyciIGluICInK0gubUQobykrJyInKQpkLnB1c2goSC5jRShzLG8sbikpfWVsc2Ug
-ZC5wdXNoKHApCnJldHVybiBtfSwKSTpmdW5jdGlvbihhLGIpe3ZhciBzPWIucG9wKCkKaWYoMD09PXMp
-e2IucHVzaChILm0oYS51LDEsIjAmIikpCnJldHVybn1pZigxPT09cyl7Yi5wdXNoKEgubShhLnUsNCwi
-MSYiKSkKcmV0dXJufXRocm93IEguYihQLmhWKCJVbmV4cGVjdGVkIGV4dGVuZGVkIG9wZXJhdGlvbiAi
-K0guRWoocykpKX0sCks6ZnVuY3Rpb24oYSxiLGMpe2lmKHR5cGVvZiBjPT0ic3RyaW5nIilyZXR1cm4g
-SC5KKGEsYyxhLnNFQSkKZWxzZSBpZih0eXBlb2YgYz09Im51bWJlciIpcmV0dXJuIEguVFYoYSxiLGMp
-CmVsc2UgcmV0dXJuIGN9LApyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPWMubGVuZ3RoCmZvcihzPTA7
-czxyOysrcyljW3NdPUguSyhhLGIsY1tzXSl9LAp5OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPWMubGVu
-Z3RoCmZvcihzPTI7czxyO3MrPTMpY1tzXT1ILksoYSxiLGNbc10pfSwKVFY6ZnVuY3Rpb24oYSxiLGMp
-e3ZhciBzLHIscT1iLnkKaWYocT09PTEwKXtpZihjPT09MClyZXR1cm4gYi56CnM9Yi5RCnI9cy5sZW5n
-dGgKaWYoYzw9cilyZXR1cm4gc1tjLTFdCmMtPXIKYj1iLnoKcT1iLnl9ZWxzZSBpZihjPT09MClyZXR1
-cm4gYgppZihxIT09OSl0aHJvdyBILmIoUC5oVigiSW5kZXhlZCBiYXNlIG11c3QgYmUgYW4gaW50ZXJm
-YWNlIHR5cGUiKSkKcz1iLlEKaWYoYzw9cy5sZW5ndGgpcmV0dXJuIHNbYy0xXQp0aHJvdyBILmIoUC5o
-VigiQmFkIGluZGV4ICIrYysiIGZvciAiK2IudygwKSkpfSwKV2U6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2
-YXIgcyxyLHEscCxvLG4sbSxsLGssagppZihiPT09ZClyZXR1cm4hMAppZighSC5BOChkKSlpZighKGQ9
-PT10Ll8pKXM9ZD09PXQuSwplbHNlIHM9ITAKZWxzZSBzPSEwCmlmKHMpcmV0dXJuITAKcj1iLnkKaWYo
-cj09PTQpcmV0dXJuITAKaWYoSC5BOChiKSlyZXR1cm4hMQppZihiLnkhPT0xKXM9Yj09PXQuUHx8Yj09
-PXQuVAplbHNlIHM9ITAKaWYocylyZXR1cm4hMApxPXI9PT0xMwppZihxKWlmKEguV2UoYSxjW2Iuel0s
-YyxkLGUpKXJldHVybiEwCnA9ZC55CmlmKHI9PT02KXJldHVybiBILldlKGEsYi56LGMsZCxlKQppZihw
-PT09Nil7cz1kLnoKcmV0dXJuIEguV2UoYSxiLGMscyxlKX1pZihyPT09OCl7aWYoIUguV2UoYSxiLnos
-YyxkLGUpKXJldHVybiExCnJldHVybiBILldlKGEsSC54WihhLGIpLGMsZCxlKX1pZihyPT09Nyl7cz1I
-LldlKGEsYi56LGMsZCxlKQpyZXR1cm4gc31pZihwPT09OCl7aWYoSC5XZShhLGIsYyxkLnosZSkpcmV0
-dXJuITAKcmV0dXJuIEguV2UoYSxiLGMsSC54WihhLGQpLGUpfWlmKHA9PT03KXtzPUguV2UoYSxiLGMs
-ZC56LGUpCnJldHVybiBzfWlmKHEpcmV0dXJuITEKcz1yIT09MTEKaWYoKCFzfHxyPT09MTIpJiZkPT09
-dC5ZKXJldHVybiEwCmlmKHA9PT0xMil7aWYoYj09PXQueClyZXR1cm4hMAppZihyIT09MTIpcmV0dXJu
-ITEKbz1iLlEKbj1kLlEKbT1vLmxlbmd0aAppZihtIT09bi5sZW5ndGgpcmV0dXJuITEKYz1jPT1udWxs
-P286by5jb25jYXQoYykKZT1lPT1udWxsP246bi5jb25jYXQoZSkKZm9yKGw9MDtsPG07KytsKXtrPW9b
-bF0Kaj1uW2xdCmlmKCFILldlKGEsayxjLGosZSl8fCFILldlKGEsaixlLGssYykpcmV0dXJuITF9cmV0
-dXJuIEguYk8oYSxiLnosYyxkLnosZSl9aWYocD09PTExKXtpZihiPT09dC54KXJldHVybiEwCmlmKHMp
-cmV0dXJuITEKcmV0dXJuIEguYk8oYSxiLGMsZCxlKX1pZihyPT09OSl7aWYocCE9PTkpcmV0dXJuITEK
-cmV0dXJuIEgucEcoYSxiLGMsZCxlKX1yZXR1cm4hMX0sCmJPOmZ1bmN0aW9uKGEyLGEzLGE0LGE1LGE2
-KXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxjLGIsYSxhMCxhMQppZighSC5XZShh
-MixhMy56LGE0LGE1LnosYTYpKXJldHVybiExCnM9YTMuUQpyPWE1LlEKcT1zLmEKcD1yLmEKbz1xLmxl
-bmd0aApuPXAubGVuZ3RoCmlmKG8+bilyZXR1cm4hMQptPW4tbwpsPXMuYgprPXIuYgpqPWwubGVuZ3Ro
-Cmk9ay5sZW5ndGgKaWYobytqPG4raSlyZXR1cm4hMQpmb3IoaD0wO2g8bzsrK2gpe2c9cVtoXQppZigh
-SC5XZShhMixwW2hdLGE2LGcsYTQpKXJldHVybiExfWZvcihoPTA7aDxtOysraCl7Zz1sW2hdCmlmKCFI
-LldlKGEyLHBbbytoXSxhNixnLGE0KSlyZXR1cm4hMX1mb3IoaD0wO2g8aTsrK2gpe2c9bFttK2hdCmlm
-KCFILldlKGEyLGtbaF0sYTYsZyxhNCkpcmV0dXJuITF9Zj1zLmMKZT1yLmMKZD1mLmxlbmd0aApjPWUu
-bGVuZ3RoCmZvcihiPTAsYT0wO2E8YzthKz0zKXthMD1lW2FdCmZvcig7ITA7KXtpZihiPj1kKXJldHVy
-biExCmExPWZbYl0KYis9MwppZihhMDxhMSlyZXR1cm4hMQppZihhMTxhMCljb250aW51ZQpnPWZbYi0x
-XQppZighSC5XZShhMixlW2ErMl0sYTYsZyxhNCkpcmV0dXJuITEKYnJlYWt9fXJldHVybiEwfSwKcEc6
-ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9Yi56LGo9ZC56CmlmKGs9PT1q
-KXtzPWIuUQpyPWQuUQpxPXMubGVuZ3RoCmZvcihwPTA7cDxxOysrcCl7bz1zW3BdCm49cltwXQppZigh
-SC5XZShhLG8sYyxuLGUpKXJldHVybiExfXJldHVybiEwfWlmKGQ9PT10LkspcmV0dXJuITAKbT1ILlFv
-KGEsaykKaWYobT09bnVsbClyZXR1cm4hMQpsPW1bal0KaWYobD09bnVsbClyZXR1cm4hMQpxPWwubGVu
-Z3RoCnI9ZC5RCmZvcihwPTA7cDxxOysrcClpZighSC5XZShhLEguY0UoYSxiLGxbcF0pLGMscltwXSxl
-KSlyZXR1cm4hMQpyZXR1cm4hMH0sCmxSOmZ1bmN0aW9uKGEpe3ZhciBzLHI9YS55CmlmKCEoYT09PXQu
-UHx8YT09PXQuVCkpaWYoIUguQTgoYSkpaWYociE9PTcpaWYoIShyPT09NiYmSC5sUihhLnopKSlzPXI9
-PT04JiZILmxSKGEueikKZWxzZSBzPSEwCmVsc2Ugcz0hMAplbHNlIHM9ITAKZWxzZSBzPSEwCnJldHVy
-biBzfSwKY2M6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoIUguQTgoYSkpaWYoIShhPT09dC5fKSlzPWE9PT10
-LksKZWxzZSBzPSEwCmVsc2Ugcz0hMApyZXR1cm4gc30sCkE4OmZ1bmN0aW9uKGEpe3ZhciBzPWEueQpy
-ZXR1cm4gcz09PTJ8fHM9PT0zfHxzPT09NHx8cz09PTV8fGE9PT10Lld9LApJeDpmdW5jdGlvbihhLGIp
-e3ZhciBzLHIscT1PYmplY3Qua2V5cyhiKSxwPXEubGVuZ3RoCmZvcihzPTA7czxwOysrcyl7cj1xW3Nd
-CmFbcl09YltyXX19LApKYzpmdW5jdGlvbiBKYyhhLGIpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy54
-PV8ucj1fLmM9bnVsbApfLnk9MApfLmN5PV8uY3g9Xy5jaD1fLlE9Xy56PW51bGx9LApHOmZ1bmN0aW9u
-IEcoKXt0aGlzLmM9dGhpcy5iPXRoaXMuYT1udWxsfSwKbFk6ZnVuY3Rpb24gbFkoYSl7dGhpcy5hPWF9
-LAprUzpmdW5jdGlvbiBrUygpe30sCmlNOmZ1bmN0aW9uIGlNKGEpe3RoaXMuYT1hfSwKUjk6ZnVuY3Rp
-b24oYSl7cmV0dXJuIHQudy5iKGEpfHx0LkIuYihhKXx8dC5kei5iKGEpfHx0LkkuYihhKXx8dC5BLmIo
-YSl8fHQuZzQuYihhKXx8dC5nMi5iKGEpfSwKSmc6ZnVuY3Rpb24oYSl7cmV0dXJuIHYubWFuZ2xlZEds
-b2JhbE5hbWVzW2FdfX0sSj17ClF1OmZ1bmN0aW9uKGEsYixjLGQpe3JldHVybntpOmEscDpiLGU6Yyx4
-OmR9fSwKa3M6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuPWFbdi5kaXNwYXRjaFByb3BlcnR5TmFt
-ZV0KaWYobj09bnVsbClpZigkLkJ2PT1udWxsKXtILlhEKCkKbj1hW3YuZGlzcGF0Y2hQcm9wZXJ0eU5h
-bWVdfWlmKG4hPW51bGwpe3M9bi5wCmlmKCExPT09cylyZXR1cm4gbi5pCmlmKCEwPT09cylyZXR1cm4g
-YQpyPU9iamVjdC5nZXRQcm90b3R5cGVPZihhKQppZihzPT09cilyZXR1cm4gbi5pCmlmKG4uZT09PXIp
-dGhyb3cgSC5iKFAuU1koIlJldHVybiBpbnRlcmNlcHRvciBmb3IgIitILkVqKHMoYSxuKSkpKX1xPWEu
-Y29uc3RydWN0b3IKaWYocT09bnVsbClwPW51bGwKZWxzZXtvPSQuem0KaWYobz09bnVsbClvPSQuem09
-di5nZXRJc29sYXRlVGFnKCJfJGRhcnRfanMiKQpwPXFbb119aWYocCE9bnVsbClyZXR1cm4gcApwPUgu
-dzMoYSkKaWYocCE9bnVsbClyZXR1cm4gcAppZih0eXBlb2YgYT09ImZ1bmN0aW9uIilyZXR1cm4gQy5E
-RwpzPU9iamVjdC5nZXRQcm90b3R5cGVPZihhKQppZihzPT1udWxsKXJldHVybiBDLlpRCmlmKHM9PT1P
-YmplY3QucHJvdG90eXBlKXJldHVybiBDLlpRCmlmKHR5cGVvZiBxPT0iZnVuY3Rpb24iKXtvPSQuem0K
-aWYobz09bnVsbClvPSQuem09di5nZXRJc29sYXRlVGFnKCJfJGRhcnRfanMiKQpPYmplY3QuZGVmaW5l
-UHJvcGVydHkocSxvLHt2YWx1ZTpDLnZCLGVudW1lcmFibGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25m
-aWd1cmFibGU6dHJ1ZX0pCnJldHVybiBDLnZCfXJldHVybiBDLnZCfSwKUWk6ZnVuY3Rpb24oYSxiKXtp
-ZihhPDB8fGE+NDI5NDk2NzI5NSl0aHJvdyBILmIoUC5URShhLDAsNDI5NDk2NzI5NSwibGVuZ3RoIixu
-dWxsKSkKcmV0dXJuIEoucHkobmV3IEFycmF5KGEpLGIpfSwKS2g6ZnVuY3Rpb24oYSxiKXtpZihhPDAp
-dGhyb3cgSC5iKFAueFkoIkxlbmd0aCBtdXN0IGJlIGEgbm9uLW5lZ2F0aXZlIGludGVnZXI6ICIrYSkp
-CnJldHVybiBILlZNKG5ldyBBcnJheShhKSxiLkMoImpkPDA+IikpfSwKcHk6ZnVuY3Rpb24oYSxiKXty
-ZXR1cm4gSi5FcChILlZNKGEsYi5DKCJqZDwwPiIpKSxiKX0sCkVwOmZ1bmN0aW9uKGEsYil7YS5maXhl
-ZCRsZW5ndGg9QXJyYXkKcmV0dXJuIGF9LAp6QzpmdW5jdGlvbihhKXthLmZpeGVkJGxlbmd0aD1BcnJh
-eQphLmltbXV0YWJsZSRsaXN0PUFycmF5CnJldHVybiBhfSwKR2E6ZnVuY3Rpb24oYSl7aWYoYTwyNTYp
-c3dpdGNoKGEpe2Nhc2UgOTpjYXNlIDEwOmNhc2UgMTE6Y2FzZSAxMjpjYXNlIDEzOmNhc2UgMzI6Y2Fz
-ZSAxMzM6Y2FzZSAxNjA6cmV0dXJuITAKZGVmYXVsdDpyZXR1cm4hMX1zd2l0Y2goYSl7Y2FzZSA1NzYw
-OmNhc2UgODE5MjpjYXNlIDgxOTM6Y2FzZSA4MTk0OmNhc2UgODE5NTpjYXNlIDgxOTY6Y2FzZSA4MTk3
-OmNhc2UgODE5ODpjYXNlIDgxOTk6Y2FzZSA4MjAwOmNhc2UgODIwMTpjYXNlIDgyMDI6Y2FzZSA4MjMy
-OmNhc2UgODIzMzpjYXNlIDgyMzk6Y2FzZSA4Mjg3OmNhc2UgMTIyODg6Y2FzZSA2NTI3OTpyZXR1cm4h
-MApkZWZhdWx0OnJldHVybiExfX0sCm1tOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpmb3Iocz1hLmxlbmd0
-aDtiPHM7KXtyPUMueEIuVyhhLGIpCmlmKHIhPT0zMiYmciE9PTEzJiYhSi5HYShyKSlicmVhazsrK2J9
-cmV0dXJuIGJ9LApjMTpmdW5jdGlvbihhLGIpe3ZhciBzLHIKZm9yKDtiPjA7Yj1zKXtzPWItMQpyPUMu
-eEIuTyhhLHMpCmlmKHIhPT0zMiYmciE9PTEzJiYhSi5HYShyKSlicmVha31yZXR1cm4gYn0sClRKOmZ1
-bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVtYmVyIilyZXR1cm4gSi5xSS5wcm90b3R5cGUKaWYodHlw
-ZW9mIGE9PSJzdHJpbmciKXJldHVybiBKLkRyLnByb3RvdHlwZQppZihhPT1udWxsKXJldHVybiBhCmlm
-KGEuY29uc3RydWN0b3I9PUFycmF5KXJldHVybiBKLmpkLnByb3RvdHlwZQppZih0eXBlb2YgYSE9Im9i
-amVjdCIpe2lmKHR5cGVvZiBhPT0iZnVuY3Rpb24iKXJldHVybiBKLmM1LnByb3RvdHlwZQpyZXR1cm4g
-YX1pZihhIGluc3RhbmNlb2YgUC5NaClyZXR1cm4gYQpyZXR1cm4gSi5rcyhhKX0sClU2OmZ1bmN0aW9u
-KGEpe2lmKHR5cGVvZiBhPT0ic3RyaW5nIilyZXR1cm4gSi5Eci5wcm90b3R5cGUKaWYoYT09bnVsbCly
-ZXR1cm4gYQppZihhLmNvbnN0cnVjdG9yPT1BcnJheSlyZXR1cm4gSi5qZC5wcm90b3R5cGUKaWYodHlw
+XSl9dmFyIHk9MApmdW5jdGlvbiBpbnN0YW5jZVRlYXJPZmZHZXR0ZXIoYSxiKXt2YXIgcz1iLmZzWzBd
+CmlmKGEpcmV0dXJuIG5ldyBGdW5jdGlvbigicGFyYW1ldGVycywgY3JlYXRlVGVhck9mZkNsYXNzLCBj
+YWNoZSIsInJldHVybiBmdW5jdGlvbiB0ZWFyT2ZmXyIrcyt5KysrIihyZWNlaXZlcikgeyIrImlmIChj
+YWNoZSA9PT0gbnVsbCkgY2FjaGUgPSBjcmVhdGVUZWFyT2ZmQ2xhc3MocGFyYW1ldGVycyk7IisicmV0
+dXJuIG5ldyBjYWNoZSh0aGlzLCByZWNlaXZlcik7IisifSIpKGIsSC5VMixudWxsKQplbHNlIHJldHVy
+biBuZXcgRnVuY3Rpb24oInBhcmFtZXRlcnMsIGNyZWF0ZVRlYXJPZmZDbGFzcywgY2FjaGUiLCJyZXR1
+cm4gZnVuY3Rpb24gdGVhck9mZl8iK3MreSsrKyIoKSB7IisiaWYgKGNhY2hlID09PSBudWxsKSBjYWNo
+ZSA9IGNyZWF0ZVRlYXJPZmZDbGFzcyhwYXJhbWV0ZXJzKTsiKyJyZXR1cm4gbmV3IGNhY2hlKHRoaXMs
+IG51bGwpOyIrIn0iKShiLEguVTIsbnVsbCl9ZnVuY3Rpb24gc3RhdGljVGVhck9mZkdldHRlcihhKXt2
+YXIgcz1udWxsCnJldHVybiBmdW5jdGlvbigpe2lmKHM9PT1udWxsKXM9SC5VMihhKS5wcm90b3R5cGUK
+cmV0dXJuIHN9fXZhciB4PTAKZnVuY3Rpb24gdGVhck9mZlBhcmFtZXRlcnMoYSxiLGMsZCxlLGYsZyxo
+LGksail7aWYodHlwZW9mIGg9PSJudW1iZXIiKWgrPXgKcmV0dXJue2NvOmEsaVM6YixpSTpjLHJDOmQs
+ZFY6ZSxjczpmLGZzOmcsZlQ6aCxhSTppfHwwLG5EQTpqfX1mdW5jdGlvbiBpbnN0YWxsU3RhdGljVGVh
+ck9mZihhLGIsYyxkLGUsZixnLGgpe3ZhciBzPXRlYXJPZmZQYXJhbWV0ZXJzKGEsdHJ1ZSxmYWxzZSxj
+LGQsZSxmLGcsaCxmYWxzZSkKdmFyIHI9c3RhdGljVGVhck9mZkdldHRlcihzKQphW2JdPXJ9ZnVuY3Rp
+b24gaW5zdGFsbEluc3RhbmNlVGVhck9mZihhLGIsYyxkLGUsZixnLGgsaSxqKXtjPSEhYwp2YXIgcz10
+ZWFyT2ZmUGFyYW1ldGVycyhhLGZhbHNlLGMsZCxlLGYsZyxoLGksISFqKQp2YXIgcj1pbnN0YW5jZVRl
+YXJPZmZHZXR0ZXIoYyxzKQphW2JdPXJ9ZnVuY3Rpb24gc2V0T3JVcGRhdGVJbnRlcmNlcHRvcnNCeVRh
+ZyhhKXt2YXIgcz12LmludGVyY2VwdG9yc0J5VGFnCmlmKCFzKXt2LmludGVyY2VwdG9yc0J5VGFnPWEK
+cmV0dXJufWNvcHlQcm9wZXJ0aWVzKGEscyl9ZnVuY3Rpb24gc2V0T3JVcGRhdGVMZWFmVGFncyhhKXt2
+YXIgcz12LmxlYWZUYWdzCmlmKCFzKXt2LmxlYWZUYWdzPWEKcmV0dXJufWNvcHlQcm9wZXJ0aWVzKGEs
+cyl9ZnVuY3Rpb24gdXBkYXRlVHlwZXMoYSl7dmFyIHM9di50eXBlcwp2YXIgcj1zLmxlbmd0aApzLnB1
+c2guYXBwbHkocyxhKQpyZXR1cm4gcn1mdW5jdGlvbiB1cGRhdGVIb2xkZXIoYSxiKXtjb3B5UHJvcGVy
+dGllcyhiLGEpCnJldHVybiBhfXZhciBodW5rSGVscGVycz1mdW5jdGlvbigpe3ZhciBzPWZ1bmN0aW9u
+KGEsYixjLGQsZSl7cmV0dXJuIGZ1bmN0aW9uKGYsZyxoLGkpe3JldHVybiBpbnN0YWxsSW5zdGFuY2VU
+ZWFyT2ZmKGYsZyxhLGIsYyxkLFtoXSxpLGUsZmFsc2UpfX0scj1mdW5jdGlvbihhLGIsYyxkKXtyZXR1
+cm4gZnVuY3Rpb24oZSxmLGcsaCl7cmV0dXJuIGluc3RhbGxTdGF0aWNUZWFyT2ZmKGUsZixhLGIsYyxb
+Z10saCxkKX19CnJldHVybntpbmhlcml0OmluaGVyaXQsaW5oZXJpdE1hbnk6aW5oZXJpdE1hbnksbWl4
+aW46bWl4aW4saW5zdGFsbFN0YXRpY1RlYXJPZmY6aW5zdGFsbFN0YXRpY1RlYXJPZmYsaW5zdGFsbElu
+c3RhbmNlVGVhck9mZjppbnN0YWxsSW5zdGFuY2VUZWFyT2ZmLF9pbnN0YW5jZV8wdTpzKDAsMCxudWxs
+LFsiJDAiXSwwKSxfaW5zdGFuY2VfMXU6cygwLDEsbnVsbCxbIiQxIl0sMCksX2luc3RhbmNlXzJ1OnMo
+MCwyLG51bGwsWyIkMiJdLDApLF9pbnN0YW5jZV8waTpzKDEsMCxudWxsLFsiJDAiXSwwKSxfaW5zdGFu
+Y2VfMWk6cygxLDEsbnVsbCxbIiQxIl0sMCksX2luc3RhbmNlXzJpOnMoMSwyLG51bGwsWyIkMiJdLDAp
+LF9zdGF0aWNfMDpyKDAsbnVsbCxbIiQwIl0sMCksX3N0YXRpY18xOnIoMSxudWxsLFsiJDEiXSwwKSxf
+c3RhdGljXzI6cigyLG51bGwsWyIkMiJdLDApLG1ha2VDb25zdExpc3Q6bWFrZUNvbnN0TGlzdCxsYXp5
+OmxhenksbGF6eUZpbmFsOmxhenlGaW5hbCxsYXp5T2xkOmxhenlPbGQsdXBkYXRlSG9sZGVyOnVwZGF0
+ZUhvbGRlcixjb252ZXJ0VG9GYXN0T2JqZWN0OmNvbnZlcnRUb0Zhc3RPYmplY3Qsc2V0RnVuY3Rpb25O
+YW1lc0lmTmVjZXNzYXJ5OnNldEZ1bmN0aW9uTmFtZXNJZk5lY2Vzc2FyeSx1cGRhdGVUeXBlczp1cGRh
+dGVUeXBlcyxzZXRPclVwZGF0ZUludGVyY2VwdG9yc0J5VGFnOnNldE9yVXBkYXRlSW50ZXJjZXB0b3Jz
+QnlUYWcsc2V0T3JVcGRhdGVMZWFmVGFnczpzZXRPclVwZGF0ZUxlYWZUYWdzfX0oKQpmdW5jdGlvbiBp
+bml0aWFsaXplRGVmZXJyZWRIdW5rKGEpe3g9di50eXBlcy5sZW5ndGgKYShodW5rSGVscGVycyx2LHcs
+JCl9dmFyIEI9ewp3UjpmdW5jdGlvbigpe3JldHVybiBuZXcgQi5xcCgiIiwiIiwiIixDLkR4KX0sCllm
+OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsaz1ILmgoYS5xKDAsInJlZ2lvbnMiKSksaj1I
+LmgoYS5xKDAsIm5hdmlnYXRpb25Db250ZW50IikpLGk9SC5oKGEucSgwLCJzb3VyY2VDb2RlIikpLGg9
+UC5GbCh0LlgsdC5kXykKZm9yKHM9dC50LmEoYS5xKDAsImVkaXRzIikpLHM9cy5nUHUocykscz1zLmdt
+KHMpLHI9dC5VLHE9dC5oNDtzLkYoKTspe3A9cy5nbCgpCm89cC5hCm49SC5RSShbXSxxKQpmb3IocD1K
+LklUKHIuYShwLmIpKTtwLkYoKTspe209cC5nbCgpCmw9Si5VNihtKQpuLnB1c2gobmV3IEIuajgoSC51
+UChsLnEobSwibGluZSIpKSxILmgobC5xKG0sImV4cGxhbmF0aW9uIikpLEgudVAobC5xKG0sIm9mZnNl
+dCIpKSkpfWguWTUoMCxvLG4pfXJldHVybiBuZXcgQi5xcChrLGosaSxoKX0sCmo4OmZ1bmN0aW9uIGo4
+KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCnFwOmZ1bmN0aW9uIHFwKGEsYixjLGQp
+e3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWR9LApmdjpmdW5jdGlvbiBmdigpe30sCk9T
+OmZ1bmN0aW9uKGEpe3ZhciBzCmlmKCEoYT49NjUmJmE8PTkwKSlzPWE+PTk3JiZhPD0xMjIKZWxzZSBz
+PSEwCnJldHVybiBzfSwKWXU6ZnVuY3Rpb24oYSxiKXt2YXIgcz1hLmxlbmd0aCxyPWIrMgppZihzPHIp
+cmV0dXJuITEKaWYoIUIuT1MoQy54Qi5PKGEsYikpKXJldHVybiExCmlmKEMueEIuTyhhLGIrMSkhPT01
+OClyZXR1cm4hMQppZihzPT09cilyZXR1cm4hMApyZXR1cm4gQy54Qi5PKGEscik9PT00N319LEM9e30s
+RD17CmFiOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz1udWxsCnRyeXtvPVAudW8oKX1jYXRjaChzKXtp
+Zih0Lmc4LmIoSC5SdShzKSkpe3I9JC5GZgppZihyIT1udWxsKXJldHVybiByCnRocm93IHN9ZWxzZSB0
+aHJvdyBzfWlmKEouUk0obywkLkk2KSl7cj0kLkZmCnIudG9TdHJpbmcKcmV0dXJuIHJ9JC5JNj1vCmlm
+KCQuSGsoKT09JC5FYigpKXI9JC5GZj1vLlpJKCIuIikudygwKQplbHNle3E9by50NCgpCnA9cS5sZW5n
+dGgtMQpyPSQuRmY9cD09PTA/cTpDLnhCLk5qKHEsMCxwKX1yLnRvU3RyaW5nCnJldHVybiByfX0sRT17
+T0Y6ZnVuY3Rpb24gT0YoYSxiLGMpe3RoaXMuZD1hCnRoaXMuZT1iCnRoaXMuZj1jfX0sRj17cnU6ZnVu
+Y3Rpb24gcnUoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmQ9YQpfLmU9YgpfLmY9YwpfLnI9ZH19LEg9e0ZL
+OmZ1bmN0aW9uIEZLKCl7fSwKR0o6ZnVuY3Rpb24oYSxiLGMpe2lmKGIuQygiYlE8MD4iKS5iKGEpKXJl
+dHVybiBuZXcgSC5vbChhLGIuQygiQDwwPiIpLktxKGMpLkMoIm9sPDEsMj4iKSkKcmV0dXJuIG5ldyBI
+Llp5KGEsYi5DKCJAPDA+IikuS3EoYykuQygiWnk8MSwyPiIpKX0sCmo6ZnVuY3Rpb24oYSl7cmV0dXJu
+IG5ldyBILm4oIkZpZWxkICciK0guRWooYSkrIicgaGFzIGJlZW4gYXNzaWduZWQgZHVyaW5nIGluaXRp
+YWxpemF0aW9uLiIpfSwKQmk6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBILnIzKGEpfSwKb286ZnVuY3Rp
+b24oYSl7dmFyIHMscj1hXjQ4CmlmKHI8PTkpcmV0dXJuIHIKcz1hfDMyCmlmKDk3PD1zJiZzPD0xMDIp
+cmV0dXJuIHMtODcKcmV0dXJuLTF9LApjYjpmdW5jdGlvbihhLGIsYyl7aWYoYT09bnVsbCl0aHJvdyBI
+LmIobmV3IEguR00oYixjLkMoIkdNPDA+IikpKQpyZXR1cm4gYX0sCnFDOmZ1bmN0aW9uKGEsYixjLGQp
+e1AuazEoYiwic3RhcnQiKQppZihjIT1udWxsKXtQLmsxKGMsImVuZCIpCmlmKGI+YylILnYoUC5URShi
+LDAsYywic3RhcnQiLG51bGwpKX1yZXR1cm4gbmV3IEgubkgoYSxiLGMsZC5DKCJuSDwwPiIpKX0sCksx
+OmZ1bmN0aW9uKGEsYixjLGQpe2lmKHQuZC5iKGEpKXJldHVybiBuZXcgSC54eShhLGIsYy5DKCJAPDA+
+IikuS3EoZCkuQygieHk8MSwyPiIpKQpyZXR1cm4gbmV3IEguaTEoYSxiLGMuQygiQDwwPiIpLktxKGQp
+LkMoImkxPDEsMj4iKSl9LApiSzpmdW5jdGlvbihhLGIsYyl7aWYodC5kLmIoYSkpe1AuazEoYiwiY291
+bnQiKQpyZXR1cm4gbmV3IEguZDUoYSxiLGMuQygiZDU8MD4iKSl9UC5rMShiLCJjb3VudCIpCnJldHVy
+biBuZXcgSC5BTShhLGIsYy5DKCJBTTwwPiIpKX0sCldwOmZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBQLmxq
+KCJObyBlbGVtZW50Iil9LApBbTpmdW5jdGlvbigpe3JldHVybiBuZXcgUC5saigiVG9vIG1hbnkgZWxl
+bWVudHMiKX0sCmFyOmZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBQLmxqKCJUb28gZmV3IGVsZW1lbnRzIil9
+LApCUjpmdW5jdGlvbiBCUigpe30sCkU3OmZ1bmN0aW9uIEU3KGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9
+Yn0sClp5OmZ1bmN0aW9uIFp5KGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCm9sOmZ1bmN0aW9uIG9s
+KGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sClVxOmZ1bmN0aW9uIFVxKCl7fSwKalY6ZnVuY3Rpb24g
+alYoYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKbjpmdW5jdGlvbiBuKGEpe3RoaXMuYT1hfSwKcjM6
+ZnVuY3Rpb24gcjMoYSl7dGhpcy5hPWF9LApxajpmdW5jdGlvbiBxaihhKXt0aGlzLmE9YX0sCkdNOmZ1
+bmN0aW9uIEdNKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCmJROmZ1bmN0aW9uIGJRKCl7fSwKYUw6
+ZnVuY3Rpb24gYUwoKXt9LApuSDpmdW5jdGlvbiBuSChhLGIsYyxkKXt2YXIgXz10aGlzCl8uYT1hCl8u
+Yj1iCl8uYz1jCl8uJHRpPWR9LAphNzpmdW5jdGlvbiBhNyhhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpf
+LmI9YgpfLmM9MApfLmQ9bnVsbApfLiR0aT1jfSwKaTE6ZnVuY3Rpb24gaTEoYSxiLGMpe3RoaXMuYT1h
+CnRoaXMuYj1iCnRoaXMuJHRpPWN9LAp4eTpmdW5jdGlvbiB4eShhLGIsYyl7dGhpcy5hPWEKdGhpcy5i
+PWIKdGhpcy4kdGk9Y30sCk1IOmZ1bmN0aW9uIE1IKGEsYixjKXt2YXIgXz10aGlzCl8uYT1udWxsCl8u
+Yj1hCl8uYz1iCl8uJHRpPWN9LApsSjpmdW5jdGlvbiBsSihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIK
+dGhpcy4kdGk9Y30sClU1OmZ1bmN0aW9uIFU1KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0
+aT1jfSwKU086ZnVuY3Rpb24gU08oYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuJHRpPWN9LApB
+TTpmdW5jdGlvbiBBTShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy4kdGk9Y30sCmQ1OmZ1bmN0
+aW9uIGQ1KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0aT1jfSwKVTE6ZnVuY3Rpb24gVTEo
+YSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuJHRpPWN9LApNQjpmdW5jdGlvbiBNQihhKXt0aGlz
+LiR0aT1hfSwKRnU6ZnVuY3Rpb24gRnUoYSl7dGhpcy4kdGk9YX0sCnU2OmZ1bmN0aW9uIHU2KGEsYil7
+dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCkpCOmZ1bmN0aW9uIEpCKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9
+Yn0sClNVOmZ1bmN0aW9uIFNVKCl7fSwKUmU6ZnVuY3Rpb24gUmUoKXt9LAp3MjpmdW5jdGlvbiB3Migp
+e30sCnd2OmZ1bmN0aW9uIHd2KGEpe3RoaXMuYT1hfSwKUUM6ZnVuY3Rpb24gUUMoKXt9LApkYzpmdW5j
+dGlvbigpe3Rocm93IEguYihQLkw0KCJDYW5ub3QgbW9kaWZ5IHVubW9kaWZpYWJsZSBNYXAiKSl9LApw
+OmZ1bmN0aW9uKGEpe3ZhciBzLHI9di5tYW5nbGVkR2xvYmFsTmFtZXNbYV0KaWYociE9bnVsbClyZXR1
+cm4gcgpzPSJtaW5pZmllZDoiK2EKcmV0dXJuIHN9LAp3VjpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKGIh
+PW51bGwpe3M9Yi54CmlmKHMhPW51bGwpcmV0dXJuIHN9cmV0dXJuIHQuYVUuYihhKX0sCkVqOmZ1bmN0
+aW9uKGEpe3ZhciBzCmlmKHR5cGVvZiBhPT0ic3RyaW5nIilyZXR1cm4gYQppZih0eXBlb2YgYT09Im51
+bWJlciIpe2lmKGEhPT0wKXJldHVybiIiK2F9ZWxzZSBpZighMD09PWEpcmV0dXJuInRydWUiCmVsc2Ug
+aWYoITE9PT1hKXJldHVybiJmYWxzZSIKZWxzZSBpZihhPT1udWxsKXJldHVybiJudWxsIgpzPUoudyhh
+KQppZih0eXBlb2YgcyE9InN0cmluZyIpdGhyb3cgSC5iKEgudEwoYSkpCnJldHVybiBzfSwKZVE6ZnVu
+Y3Rpb24oYSl7dmFyIHM9YS4kaWRlbnRpdHlIYXNoCmlmKHM9PW51bGwpe3M9TWF0aC5yYW5kb20oKSow
+eDNmZmZmZmZmfDAKYS4kaWRlbnRpdHlIYXNoPXN9cmV0dXJuIHN9LApIcDpmdW5jdGlvbihhLGIpe3Zh
+ciBzLHIscSxwLG8sbixtPW51bGwKaWYodHlwZW9mIGEhPSJzdHJpbmciKUgudihILnRMKGEpKQpzPS9e
+XHMqWystXT8oKDB4W2EtZjAtOV0rKXwoXGQrKXwoW2EtejAtOV0rKSlccyokL2kuZXhlYyhhKQppZihz
+PT1udWxsKXJldHVybiBtCmlmKDM+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsMykKcj1zWzNdCmlmKGI9
+PW51bGwpe2lmKHIhPW51bGwpcmV0dXJuIHBhcnNlSW50KGEsMTApCmlmKHNbMl0hPW51bGwpcmV0dXJu
+IHBhcnNlSW50KGEsMTYpCnJldHVybiBtfWlmKGI8Mnx8Yj4zNil0aHJvdyBILmIoUC5URShiLDIsMzYs
+InJhZGl4IixtKSkKaWYoYj09PTEwJiZyIT1udWxsKXJldHVybiBwYXJzZUludChhLDEwKQppZihiPDEw
+fHxyPT1udWxsKXtxPWI8PTEwPzQ3K2I6ODYrYgpwPXNbMV0KZm9yKG89cC5sZW5ndGgsbj0wO248bzsr
+K24paWYoKEMueEIuVyhwLG4pfDMyKT5xKXJldHVybiBtfXJldHVybiBwYXJzZUludChhLGIpfSwKbGg6
+ZnVuY3Rpb24oYSl7cmV0dXJuIEguSDUoYSl9LApINTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscAppZihh
+IGluc3RhbmNlb2YgUC5NaClyZXR1cm4gSC5kbShILnpLKGEpLG51bGwpCmlmKEouaWEoYSk9PT1DLk9r
+fHx0LmJKLmIoYSkpe3M9Qy5PNChhKQpyPXMhPT0iT2JqZWN0IiYmcyE9PSIiCmlmKHIpcmV0dXJuIHMK
+cT1hLmNvbnN0cnVjdG9yCmlmKHR5cGVvZiBxPT0iZnVuY3Rpb24iKXtwPXEubmFtZQppZih0eXBlb2Yg
+cD09InN0cmluZyIpcj1wIT09Ik9iamVjdCImJnAhPT0iIgplbHNlIHI9ITEKaWYocilyZXR1cm4gcH19
+cmV0dXJuIEguZG0oSC56SyhhKSxudWxsKX0sCk0wOmZ1bmN0aW9uKCl7aWYoISFzZWxmLmxvY2F0aW9u
+KXJldHVybiBzZWxmLmxvY2F0aW9uLmhyZWYKcmV0dXJuIG51bGx9LApWSzpmdW5jdGlvbihhKXt2YXIg
+cyxyLHEscCxvPWEubGVuZ3RoCmlmKG88PTUwMClyZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZS5hcHBs
+eShudWxsLGEpCmZvcihzPSIiLHI9MDtyPG87cj1xKXtxPXIrNTAwCnA9cTxvP3E6bwpzKz1TdHJpbmcu
+ZnJvbUNoYXJDb2RlLmFwcGx5KG51bGwsYS5zbGljZShyLHApKX1yZXR1cm4gc30sCkNxOmZ1bmN0aW9u
+KGEpe3ZhciBzLHIscSxwPUguUUkoW10sdC5hKQpmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDth
+Lmxlbmd0aD09PXN8fCgwLEgubGspKGEpLCsrcil7cT1hW3JdCmlmKCFILm9rKHEpKXRocm93IEguYihI
+LnRMKHEpKQppZihxPD02NTUzNSlDLk5tLmkocCxxKQplbHNlIGlmKHE8PTExMTQxMTEpe0MuTm0uaShw
+LDU1Mjk2KyhDLmpuLndHKHEtNjU1MzYsMTApJjEwMjMpKQpDLk5tLmkocCw1NjMyMCsocSYxMDIzKSl9
+ZWxzZSB0aHJvdyBILmIoSC50TChxKSl9cmV0dXJuIEguVksocCl9LAplVDpmdW5jdGlvbihhKXt2YXIg
+cyxyLHEKZm9yKHM9YS5sZW5ndGgscj0wO3I8czsrK3Ipe3E9YVtyXQppZighSC5vayhxKSl0aHJvdyBI
+LmIoSC50TChxKSkKaWYocTwwKXRocm93IEguYihILnRMKHEpKQppZihxPjY1NTM1KXJldHVybiBILkNx
+KGEpfXJldHVybiBILlZLKGEpfSwKZnc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwCmlmKGM8PTUw
+MCYmYj09PTAmJmM9PT1hLmxlbmd0aClyZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZS5hcHBseShudWxs
+LGEpCmZvcihzPWIscj0iIjtzPGM7cz1xKXtxPXMrNTAwCnA9cTxjP3E6YwpyKz1TdHJpbmcuZnJvbUNo
+YXJDb2RlLmFwcGx5KG51bGwsYS5zdWJhcnJheShzLHApKX1yZXR1cm4gcn0sCkx3OmZ1bmN0aW9uKGEp
+e3ZhciBzCmlmKDA8PWEpe2lmKGE8PTY1NTM1KXJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2RlKGEpCmlm
+KGE8PTExMTQxMTEpe3M9YS02NTUzNgpyZXR1cm4gU3RyaW5nLmZyb21DaGFyQ29kZSgoQy5qbi53Ryhz
+LDEwKXw1NTI5Nik+Pj4wLHMmMTAyM3w1NjMyMCl9fXRocm93IEguYihQLlRFKGEsMCwxMTE0MTExLG51
+bGwsbnVsbCkpfSwKbzI6ZnVuY3Rpb24oYSl7aWYoYS5kYXRlPT09dm9pZCAwKWEuZGF0ZT1uZXcgRGF0
+ZShhLmEpCnJldHVybiBhLmRhdGV9LAp0SjpmdW5jdGlvbihhKXt2YXIgcz1ILm8yKGEpLmdldEZ1bGxZ
+ZWFyKCkrMApyZXR1cm4gc30sCk5TOmZ1bmN0aW9uKGEpe3ZhciBzPUgubzIoYSkuZ2V0TW9udGgoKSsx
+CnJldHVybiBzfSwKakE6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vMihhKS5nZXREYXRlKCkrMApyZXR1cm4g
+c30sCklYOmZ1bmN0aW9uKGEpe3ZhciBzPUgubzIoYSkuZ2V0SG91cnMoKSswCnJldHVybiBzfSwKY2g6
+ZnVuY3Rpb24oYSl7dmFyIHM9SC5vMihhKS5nZXRNaW51dGVzKCkrMApyZXR1cm4gc30sCkpkOmZ1bmN0
+aW9uKGEpe3ZhciBzPUgubzIoYSkuZ2V0U2Vjb25kcygpKzAKcmV0dXJuIHN9LApvMTpmdW5jdGlvbihh
+KXt2YXIgcz1ILm8yKGEpLmdldE1pbGxpc2Vjb25kcygpKzAKcmV0dXJuIHN9LAp6bzpmdW5jdGlvbihh
+LGIsYyl7dmFyIHMscixxPXt9CnEuYT0wCnM9W10Kcj1bXQpxLmE9Yi5sZW5ndGgKQy5ObS5GVihzLGIp
+CnEuYj0iIgppZihjIT1udWxsJiZjLmEhPT0wKWMuSygwLG5ldyBILkNqKHEscixzKSkKIiIrcS5hCnJl
+dHVybiBKLkp5KGEsbmV3IEguTEkoQy5UZSwwLHMsciwwKSl9LApFazpmdW5jdGlvbihhLGIsYyl7dmFy
+IHMscixxLHAKaWYoYiBpbnN0YW5jZW9mIEFycmF5KXM9Yz09bnVsbHx8Yy5hPT09MAplbHNlIHM9ITEK
+aWYocyl7cj1iCnE9ci5sZW5ndGgKaWYocT09PTApe2lmKCEhYS4kMClyZXR1cm4gYS4kMCgpfWVsc2Ug
+aWYocT09PTEpe2lmKCEhYS4kMSlyZXR1cm4gYS4kMShyWzBdKX1lbHNlIGlmKHE9PT0yKXtpZighIWEu
+JDIpcmV0dXJuIGEuJDIoclswXSxyWzFdKX1lbHNlIGlmKHE9PT0zKXtpZighIWEuJDMpcmV0dXJuIGEu
+JDMoclswXSxyWzFdLHJbMl0pfWVsc2UgaWYocT09PTQpe2lmKCEhYS4kNClyZXR1cm4gYS4kNChyWzBd
+LHJbMV0sclsyXSxyWzNdKX1lbHNlIGlmKHE9PT01KWlmKCEhYS4kNSlyZXR1cm4gYS4kNShyWzBdLHJb
+MV0sclsyXSxyWzNdLHJbNF0pCnA9YVsiIisiJCIrcV0KaWYocCE9bnVsbClyZXR1cm4gcC5hcHBseShh
+LHIpfXJldHVybiBILmUxKGEsYixjKX0sCmUxOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4s
+bSxsLGssaixpPWIgaW5zdGFuY2VvZiBBcnJheT9iOlAuQ0goYiwhMCx0LnopLGg9aS5sZW5ndGgsZz1h
+LiRSCmlmKGg8ZylyZXR1cm4gSC56byhhLGksYykKcz1hLiRECnI9cz09bnVsbApxPSFyP3MoKTpudWxs
+CnA9Si5pYShhKQpvPXAuJEMKaWYodHlwZW9mIG89PSJzdHJpbmciKW89cFtvXQppZihyKXtpZihjIT1u
+dWxsJiZjLmEhPT0wKXJldHVybiBILnpvKGEsaSxjKQppZihoPT09ZylyZXR1cm4gby5hcHBseShhLGkp
+CnJldHVybiBILnpvKGEsaSxjKX1pZihxIGluc3RhbmNlb2YgQXJyYXkpe2lmKGMhPW51bGwmJmMuYSE9
+PTApcmV0dXJuIEguem8oYSxpLGMpCmlmKGg+ZytxLmxlbmd0aClyZXR1cm4gSC56byhhLGksbnVsbCkK
+Qy5ObS5GVihpLHEuc2xpY2UoaC1nKSkKcmV0dXJuIG8uYXBwbHkoYSxpKX1lbHNle2lmKGg+ZylyZXR1
+cm4gSC56byhhLGksYykKbj1PYmplY3Qua2V5cyhxKQppZihjPT1udWxsKWZvcihyPW4ubGVuZ3RoLG09
+MDttPG4ubGVuZ3RoO24ubGVuZ3RoPT09cnx8KDAsSC5saykobiksKyttKXtsPXFbSC5oKG5bbV0pXQpp
+ZihDLk52PT09bClyZXR1cm4gSC56byhhLGksYykKQy5ObS5pKGksbCl9ZWxzZXtmb3Iocj1uLmxlbmd0
+aCxrPTAsbT0wO208bi5sZW5ndGg7bi5sZW5ndGg9PT1yfHwoMCxILmxrKShuKSwrK20pe2o9SC5oKG5b
+bV0pCmlmKGMueDQoaikpeysrawpDLk5tLmkoaSxjLnEoMCxqKSl9ZWxzZXtsPXFbal0KaWYoQy5Odj09
+PWwpcmV0dXJuIEguem8oYSxpLGMpCkMuTm0uaShpLGwpfX1pZihrIT09Yy5hKXJldHVybiBILnpvKGEs
+aSxjKX1yZXR1cm4gby5hcHBseShhLGkpfX0sCnBZOmZ1bmN0aW9uKGEpe3Rocm93IEguYihILnRMKGEp
+KX0sCk9IOmZ1bmN0aW9uKGEsYil7aWYoYT09bnVsbClKLkhtKGEpCnRocm93IEguYihILnUoYSxiKSl9
+LAp1OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPSJpbmRleCIKaWYoIUgub2soYikpcmV0dXJuIG5ldyBQ
+LmMoITAsYixxLG51bGwpCnM9SC51UChKLkhtKGEpKQppZighKGI8MCkpe2lmKHR5cGVvZiBzIT09Im51
+bWJlciIpcmV0dXJuIEgucFkocykKcj1iPj1zfWVsc2Ugcj0hMAppZihyKXJldHVybiBQLkNmKGIsYSxx
+LG51bGwscykKcmV0dXJuIFAuTzcoYixxKX0sCkR1OmZ1bmN0aW9uKGEsYixjKXtpZihhPmMpcmV0dXJu
+IFAuVEUoYSwwLGMsInN0YXJ0IixudWxsKQppZihiIT1udWxsKWlmKGI8YXx8Yj5jKXJldHVybiBQLlRF
+KGIsYSxjLCJlbmQiLG51bGwpCnJldHVybiBuZXcgUC5jKCEwLGIsImVuZCIsbnVsbCl9LAp0TDpmdW5j
+dGlvbihhKXtyZXR1cm4gbmV3IFAuYyghMCxhLG51bGwsbnVsbCl9LApiOmZ1bmN0aW9uKGEpe3ZhciBz
+LHIKaWYoYT09bnVsbClhPW5ldyBQLkxLKCkKcz1uZXcgRXJyb3IoKQpzLmRhcnRFeGNlcHRpb249YQpy
+PUguSnUKaWYoImRlZmluZVByb3BlcnR5IiBpbiBPYmplY3Qpe09iamVjdC5kZWZpbmVQcm9wZXJ0eShz
+LCJtZXNzYWdlIix7Z2V0OnJ9KQpzLm5hbWU9IiJ9ZWxzZSBzLnRvU3RyaW5nPXIKcmV0dXJuIHN9LApK
+dTpmdW5jdGlvbigpe3JldHVybiBKLncodGhpcy5kYXJ0RXhjZXB0aW9uKX0sCnY6ZnVuY3Rpb24oYSl7
+dGhyb3cgSC5iKGEpfSwKbGs6ZnVuY3Rpb24oYSl7dGhyb3cgSC5iKFAuYTQoYSkpfSwKY006ZnVuY3Rp
+b24oYSl7dmFyIHMscixxLHAsbyxuCmE9SC5lQShhLnJlcGxhY2UoU3RyaW5nKHt9KSwiJHJlY2VpdmVy
+JCIpKQpzPWEubWF0Y2goL1xcXCRbYS16QS1aXStcXFwkL2cpCmlmKHM9PW51bGwpcz1ILlFJKFtdLHQu
+cykKcj1zLmluZGV4T2YoIlxcJGFyZ3VtZW50c1xcJCIpCnE9cy5pbmRleE9mKCJcXCRhcmd1bWVudHNF
+eHByXFwkIikKcD1zLmluZGV4T2YoIlxcJGV4cHJcXCQiKQpvPXMuaW5kZXhPZigiXFwkbWV0aG9kXFwk
+IikKbj1zLmluZGV4T2YoIlxcJHJlY2VpdmVyXFwkIikKcmV0dXJuIG5ldyBILmY5KGEucmVwbGFjZShu
+ZXcgUmVnRXhwKCJcXFxcXFwkYXJndW1lbnRzXFxcXFxcJCIsImciKSwiKCg/Onh8W154XSkqKSIpLnJl
+cGxhY2UobmV3IFJlZ0V4cCgiXFxcXFxcJGFyZ3VtZW50c0V4cHJcXFxcXFwkIiwiZyIpLCIoKD86eHxb
+XnhdKSopIikucmVwbGFjZShuZXcgUmVnRXhwKCJcXFxcXFwkZXhwclxcXFxcXCQiLCJnIiksIigoPzp4
+fFteeF0pKikiKS5yZXBsYWNlKG5ldyBSZWdFeHAoIlxcXFxcXCRtZXRob2RcXFxcXFwkIiwiZyIpLCIo
+KD86eHxbXnhdKSopIikucmVwbGFjZShuZXcgUmVnRXhwKCJcXFxcXFwkcmVjZWl2ZXJcXFxcXFwkIiwi
+ZyIpLCIoKD86eHxbXnhdKSopIikscixxLHAsbyxuKX0sClM3OmZ1bmN0aW9uKGEpe3JldHVybiBmdW5j
+dGlvbigkZXhwciQpe3ZhciAkYXJndW1lbnRzRXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7JGV4cHIkLiRt
+ZXRob2QkKCRhcmd1bWVudHNFeHByJCl9Y2F0Y2gocyl7cmV0dXJuIHMubWVzc2FnZX19KGEpfSwKTWo6
+ZnVuY3Rpb24oYSl7cmV0dXJuIGZ1bmN0aW9uKCRleHByJCl7dHJ5eyRleHByJC4kbWV0aG9kJH1jYXRj
+aChzKXtyZXR1cm4gcy5tZXNzYWdlfX0oYSl9LApUMzpmdW5jdGlvbihhLGIpe3ZhciBzPWI9PW51bGws
+cj1zP251bGw6Yi5tZXRob2QKcmV0dXJuIG5ldyBILmF6KGEscixzP251bGw6Yi5yZWNlaXZlcil9LApS
+dTpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJldHVybiBuZXcgSC50ZShhKQppZihhIGluc3RhbmNlb2Yg
+SC5icSlyZXR1cm4gSC50VyhhLGEuYSkKaWYodHlwZW9mIGEhPT0ib2JqZWN0IilyZXR1cm4gYQppZigi
+ZGFydEV4Y2VwdGlvbiIgaW4gYSlyZXR1cm4gSC50VyhhLGEuZGFydEV4Y2VwdGlvbikKcmV0dXJuIEgu
+dGwoYSl9LAp0VzpmdW5jdGlvbihhLGIpe2lmKHQuci5iKGIpKWlmKGIuJHRocm93bkpzRXJyb3I9PW51
+bGwpYi4kdGhyb3duSnNFcnJvcj1hCnJldHVybiBifSwKdGw6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAs
+byxuLG0sbCxrLGosaSxoLGcsZixlPW51bGwKaWYoISgibWVzc2FnZSIgaW4gYSkpcmV0dXJuIGEKcz1h
+Lm1lc3NhZ2UKaWYoIm51bWJlciIgaW4gYSYmdHlwZW9mIGEubnVtYmVyPT0ibnVtYmVyIil7cj1hLm51
+bWJlcgpxPXImNjU1MzUKaWYoKEMuam4ud0cociwxNikmODE5MSk9PT0xMClzd2l0Y2gocSl7Y2FzZSA0
+Mzg6cmV0dXJuIEgudFcoYSxILlQzKEguRWoocykrIiAoRXJyb3IgIitxKyIpIixlKSkKY2FzZSA0NDU6
+Y2FzZSA1MDA3OnA9SC5FaihzKSsiIChFcnJvciAiK3ErIikiCnJldHVybiBILnRXKGEsbmV3IEguVzAo
+cCxlKSl9fWlmKGEgaW5zdGFuY2VvZiBUeXBlRXJyb3Ipe289JC5TbigpCm49JC5scSgpCm09JC5OOSgp
+Cmw9JC5pSSgpCms9JC5VTigpCmo9JC5aaCgpCmk9JC5yTigpCiQuYzMoKQpoPSQuSEsoKQpnPSQucjEo
+KQpmPW8ucVMocykKaWYoZiE9bnVsbClyZXR1cm4gSC50VyhhLEguVDMoSC5oKHMpLGYpKQplbHNle2Y9
+bi5xUyhzKQppZihmIT1udWxsKXtmLm1ldGhvZD0iY2FsbCIKcmV0dXJuIEgudFcoYSxILlQzKEguaChz
+KSxmKSl9ZWxzZXtmPW0ucVMocykKaWYoZj09bnVsbCl7Zj1sLnFTKHMpCmlmKGY9PW51bGwpe2Y9ay5x
+UyhzKQppZihmPT1udWxsKXtmPWoucVMocykKaWYoZj09bnVsbCl7Zj1pLnFTKHMpCmlmKGY9PW51bGwp
+e2Y9bC5xUyhzKQppZihmPT1udWxsKXtmPWgucVMocykKaWYoZj09bnVsbCl7Zj1nLnFTKHMpCnA9ZiE9
+bnVsbH1lbHNlIHA9ITB9ZWxzZSBwPSEwfWVsc2UgcD0hMH1lbHNlIHA9ITB9ZWxzZSBwPSEwfWVsc2Ug
+cD0hMH1lbHNlIHA9ITAKaWYocCl7SC5oKHMpCnJldHVybiBILnRXKGEsbmV3IEguVzAocyxmPT1udWxs
+P2U6Zi5tZXRob2QpKX19fXJldHVybiBILnRXKGEsbmV3IEgudlYodHlwZW9mIHM9PSJzdHJpbmciP3M6
+IiIpKX1pZihhIGluc3RhbmNlb2YgUmFuZ2VFcnJvcil7aWYodHlwZW9mIHM9PSJzdHJpbmciJiZzLmlu
+ZGV4T2YoImNhbGwgc3RhY2siKSE9PS0xKXJldHVybiBuZXcgUC5LWSgpCnM9ZnVuY3Rpb24oYil7dHJ5
+e3JldHVybiBTdHJpbmcoYil9Y2F0Y2goZCl7fXJldHVybiBudWxsfShhKQpyZXR1cm4gSC50VyhhLG5l
+dyBQLmMoITEsZSxlLHR5cGVvZiBzPT0ic3RyaW5nIj9zLnJlcGxhY2UoL15SYW5nZUVycm9yOlxzKi8s
+IiIpOnMpKX1pZih0eXBlb2YgSW50ZXJuYWxFcnJvcj09ImZ1bmN0aW9uIiYmYSBpbnN0YW5jZW9mIElu
+dGVybmFsRXJyb3IpaWYodHlwZW9mIHM9PSJzdHJpbmciJiZzPT09InRvbyBtdWNoIHJlY3Vyc2lvbiIp
+cmV0dXJuIG5ldyBQLktZKCkKcmV0dXJuIGF9LAp0czpmdW5jdGlvbihhKXt2YXIgcwppZihhIGluc3Rh
+bmNlb2YgSC5icSlyZXR1cm4gYS5iCmlmKGE9PW51bGwpcmV0dXJuIG5ldyBILlhPKGEpCnM9YS4kY2Fj
+aGVkVHJhY2UKaWYocyE9bnVsbClyZXR1cm4gcwpyZXR1cm4gYS4kY2FjaGVkVHJhY2U9bmV3IEguWE8o
+YSl9LApCNzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPWEubGVuZ3RoCmZvcihzPTA7czxwO3M9cSl7
+cj1zKzEKcT1yKzEKYi5ZNSgwLGFbc10sYVtyXSl9cmV0dXJuIGJ9LApmdDpmdW5jdGlvbihhLGIsYyxk
+LGUsZil7dC5ZLmEoYSkKc3dpdGNoKEgudVAoYikpe2Nhc2UgMDpyZXR1cm4gYS4kMCgpCmNhc2UgMTpy
+ZXR1cm4gYS4kMShjKQpjYXNlIDI6cmV0dXJuIGEuJDIoYyxkKQpjYXNlIDM6cmV0dXJuIGEuJDMoYyxk
+LGUpCmNhc2UgNDpyZXR1cm4gYS4kNChjLGQsZSxmKX10aHJvdyBILmIobmV3IFAuQ0QoIlVuc3VwcG9y
+dGVkIG51bWJlciBvZiBhcmd1bWVudHMgZm9yIHdyYXBwZWQgY2xvc3VyZSIpKX0sCnRSOmZ1bmN0aW9u
+KGEsYil7dmFyIHMKaWYoYT09bnVsbClyZXR1cm4gbnVsbApzPWEuJGlkZW50aXR5CmlmKCEhcylyZXR1
+cm4gcwpzPWZ1bmN0aW9uKGMsZCxlKXtyZXR1cm4gZnVuY3Rpb24oZixnLGgsaSl7cmV0dXJuIGUoYyxk
+LGYsZyxoLGkpfX0oYSxiLEguZnQpCmEuJGlkZW50aXR5PXMKcmV0dXJuIHN9LAppQTpmdW5jdGlvbihh
+Mil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT1hMi5jbyxoPWEyLmlTLGc9YTIuaUksZj1hMi5uREEs
+ZT1hMi5hSSxkPWEyLmZzLGM9YTIuY3MsYj1kWzBdLGE9Y1swXSxhMD1pW2JdLGExPWEyLmZUCmExLnRv
+U3RyaW5nCkgub1QoaCkKcz1oP09iamVjdC5jcmVhdGUobmV3IEguengoKS5jb25zdHJ1Y3Rvci5wcm90
+b3R5cGUpOk9iamVjdC5jcmVhdGUobmV3IEguclQobnVsbCxudWxsKS5jb25zdHJ1Y3Rvci5wcm90b3R5
+cGUpCnMuJGluaXRpYWxpemU9cy5jb25zdHJ1Y3RvcgppZihoKXI9ZnVuY3Rpb24gc3RhdGljX3RlYXJf
+b2ZmKCl7dGhpcy4kaW5pdGlhbGl6ZSgpfQplbHNle3E9JC55agppZih0eXBlb2YgcSE9PSJudW1iZXIi
+KXJldHVybiBxLmgoKQokLnlqPXErMQpxPW5ldyBGdW5jdGlvbigiYSxiIitxLCJ0aGlzLiRpbml0aWFs
+aXplKGEsYiIrcSsiKSIpCnI9cX1zLmNvbnN0cnVjdG9yPXIKci5wcm90b3R5cGU9cwpzLiRfbmFtZT1i
+CnMuJF90YXJnZXQ9YTAKcT0haAppZihxKXA9SC5ieChiLGEwLGcsZikKZWxzZXtzLiRzdGF0aWNfbmFt
+ZT1iCnA9YTB9cy4kUz1ILmltKGExLGgsZykKc1thXT1wCmZvcihvPXAsbj0xO248ZC5sZW5ndGg7Kytu
+KXttPWRbbl0KaWYodHlwZW9mIG09PSJzdHJpbmciKXtsPWlbbV0Kaz1tCm09bH1lbHNlIGs9IiIKaj1j
+W25dCmlmKGohPW51bGwpe2lmKHEpbT1ILmJ4KGssbSxnLGYpCnNbal09bX1pZihuPT09ZSlvPW19cy4k
+Qz1vCnMuJFI9YTIuckMKcy4kRD1hMi5kVgpyZXR1cm4gcn0sCmltOmZ1bmN0aW9uKGEsYixjKXt2YXIg
+cwppZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGZ1bmN0aW9uKGQsZSl7cmV0dXJuIGZ1bmN0aW9u
+KCl7cmV0dXJuIGQoZSl9fShILkJwLGEpCmlmKHR5cGVvZiBhPT0ic3RyaW5nIil7aWYoSC5vVChiKSl0
+aHJvdyBILmIoIkNhbm5vdCBjb21wdXRlIHNpZ25hdHVyZSBmb3Igc3RhdGljIHRlYXJvZmYuIikKcz1I
+Lm9UKGMpP0guUFc6SC5UbgpyZXR1cm4gZnVuY3Rpb24oZCxlKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1
+cm4gZSh0aGlzLGQpfX0oYSxzKX10aHJvdyBILmIoIkVycm9yIGluIGZ1bmN0aW9uVHlwZSBvZiB0ZWFy
+b2ZmIil9LAp2cTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1ILkRWCnN3aXRjaChILm9UKGIpPy0xOmEp
+e2Nhc2UgMDpyZXR1cm4gZnVuY3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4gZih0aGlz
+KVtlXSgpfX0oYyxzKQpjYXNlIDE6cmV0dXJuIGZ1bmN0aW9uKGUsZil7cmV0dXJuIGZ1bmN0aW9uKGcp
+e3JldHVybiBmKHRoaXMpW2VdKGcpfX0oYyxzKQpjYXNlIDI6cmV0dXJuIGZ1bmN0aW9uKGUsZil7cmV0
+dXJuIGZ1bmN0aW9uKGcsaCl7cmV0dXJuIGYodGhpcylbZV0oZyxoKX19KGMscykKY2FzZSAzOnJldHVy
+biBmdW5jdGlvbihlLGYpe3JldHVybiBmdW5jdGlvbihnLGgsaSl7cmV0dXJuIGYodGhpcylbZV0oZyxo
+LGkpfX0oYyxzKQpjYXNlIDQ6cmV0dXJuIGZ1bmN0aW9uKGUsZil7cmV0dXJuIGZ1bmN0aW9uKGcsaCxp
+LGope3JldHVybiBmKHRoaXMpW2VdKGcsaCxpLGopfX0oYyxzKQpjYXNlIDU6cmV0dXJuIGZ1bmN0aW9u
+KGUsZil7cmV0dXJuIGZ1bmN0aW9uKGcsaCxpLGosayl7cmV0dXJuIGYodGhpcylbZV0oZyxoLGksaixr
+KX19KGMscykKZGVmYXVsdDpyZXR1cm4gZnVuY3Rpb24oZSxmKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1
+cm4gZS5hcHBseShmKHRoaXMpLGFyZ3VtZW50cyl9fShkLHMpfX0sCmJ4OmZ1bmN0aW9uKGEsYixjLGQp
+e3ZhciBzLHIscSxwLG8KaWYoSC5vVChjKSlyZXR1cm4gSC5IZihhLGIsZCkKcz1iLmxlbmd0aApyPUgu
+b1QoZCl8fHM+PTI3CmlmKHIpcmV0dXJuIEgudnEocyxkLGEsYikKaWYocz09PTApe3I9JC55agppZih0
+eXBlb2YgciE9PSJudW1iZXIiKXJldHVybiByLmgoKQokLnlqPXIrMQpxPSJzZWxmIityCnI9InJldHVy
+biBmdW5jdGlvbigpe3ZhciAiK3ErIiA9IHRoaXMuIgpwPSQuV1cKcmV0dXJuIG5ldyBGdW5jdGlvbihy
+KyhwPT1udWxsPyQuV1c9SC5tOSgic2VsZiIpOnApKyI7cmV0dXJuICIrcSsiLiIrSC5FaihhKSsiKCk7
+fSIpKCl9bz0iYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoiLnNwbGl0KCIiKS5zcGxpY2UoMCxzKS5q
+b2luKCIsIikKcj0kLnlqCmlmKHR5cGVvZiByIT09Im51bWJlciIpcmV0dXJuIHIuaCgpCiQueWo9cisx
+Cm8rPXIKcj0icmV0dXJuIGZ1bmN0aW9uKCIrbysiKXtyZXR1cm4gdGhpcy4iCnA9JC5XVwpyZXR1cm4g
+bmV3IEZ1bmN0aW9uKHIrKHA9PW51bGw/JC5XVz1ILm05KCJzZWxmIik6cCkrIi4iK0guRWooYSkrIigi
+K28rIik7fSIpKCl9LApaNDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1ILkRWLHI9SC55Uwpzd2l0Y2go
+SC5vVChiKT8tMTphKXtjYXNlIDA6dGhyb3cgSC5iKG5ldyBILkVxKCJJbnRlcmNlcHRlZCBmdW5jdGlv
+biB3aXRoIG5vIGFyZ3VtZW50cy4iKSkKY2FzZSAxOnJldHVybiBmdW5jdGlvbihlLGYsZyl7cmV0dXJu
+IGZ1bmN0aW9uKCl7cmV0dXJuIGYodGhpcylbZV0oZyh0aGlzKSl9fShjLHMscikKY2FzZSAyOnJldHVy
+biBmdW5jdGlvbihlLGYsZyl7cmV0dXJuIGZ1bmN0aW9uKGgpe3JldHVybiBmKHRoaXMpW2VdKGcodGhp
+cyksaCl9fShjLHMscikKY2FzZSAzOnJldHVybiBmdW5jdGlvbihlLGYsZyl7cmV0dXJuIGZ1bmN0aW9u
+KGgsaSl7cmV0dXJuIGYodGhpcylbZV0oZyh0aGlzKSxoLGkpfX0oYyxzLHIpCmNhc2UgNDpyZXR1cm4g
+ZnVuY3Rpb24oZSxmLGcpe3JldHVybiBmdW5jdGlvbihoLGksail7cmV0dXJuIGYodGhpcylbZV0oZyh0
+aGlzKSxoLGksail9fShjLHMscikKY2FzZSA1OnJldHVybiBmdW5jdGlvbihlLGYsZyl7cmV0dXJuIGZ1
+bmN0aW9uKGgsaSxqLGspe3JldHVybiBmKHRoaXMpW2VdKGcodGhpcyksaCxpLGosayl9fShjLHMscikK
+Y2FzZSA2OnJldHVybiBmdW5jdGlvbihlLGYsZyl7cmV0dXJuIGZ1bmN0aW9uKGgsaSxqLGssbCl7cmV0
+dXJuIGYodGhpcylbZV0oZyh0aGlzKSxoLGksaixrLGwpfX0oYyxzLHIpCmRlZmF1bHQ6cmV0dXJuIGZ1
+bmN0aW9uKGUsZixnLGgpe3JldHVybiBmdW5jdGlvbigpe2g9W2codGhpcyldCkFycmF5LnByb3RvdHlw
+ZS5wdXNoLmFwcGx5KGgsYXJndW1lbnRzKQpyZXR1cm4gZS5hcHBseShmKHRoaXMpLGgpfX0oZCxzLHIp
+fX0sCkhmOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG49JC5XVwppZihuPT1udWxsKW49JC5X
+Vz1ILm05KCJzZWxmIikKcz0kLmkwCmlmKHM9PW51bGwpcz0kLmkwPUgubTkoInJlY2VpdmVyIikKcj1i
+Lmxlbmd0aApxPUgub1QoYyl8fHI+PTI4CmlmKHEpcmV0dXJuIEguWjQocixjLGEsYikKaWYocj09PTEp
+e3E9InJldHVybiBmdW5jdGlvbigpe3JldHVybiB0aGlzLiIrbisiLiIrSC5FaihhKSsiKHRoaXMuIitz
+KyIpOyIKcD0kLnlqCmlmKHR5cGVvZiBwIT09Im51bWJlciIpcmV0dXJuIHAuaCgpCiQueWo9cCsxCnJl
+dHVybiBuZXcgRnVuY3Rpb24ocStwKyJ9IikoKX1vPSJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5eiIu
+c3BsaXQoIiIpLnNwbGljZSgwLHItMSkuam9pbigiLCIpCnE9InJldHVybiBmdW5jdGlvbigiK28rIil7
+cmV0dXJuIHRoaXMuIituKyIuIitILkVqKGEpKyIodGhpcy4iK3MrIiwgIitvKyIpOyIKcD0kLnlqCmlm
+KHR5cGVvZiBwIT09Im51bWJlciIpcmV0dXJuIHAuaCgpCiQueWo9cCsxCnJldHVybiBuZXcgRnVuY3Rp
+b24ocStwKyJ9IikoKX0sClUyOmZ1bmN0aW9uKGEpe3JldHVybiBILmlBKGEpfSwKVG46ZnVuY3Rpb24o
+YSxiKXtyZXR1cm4gSC5jRSh2LnR5cGVVbml2ZXJzZSxILnpLKGEuYSksYil9LApQVzpmdW5jdGlvbihh
+LGIpe3JldHVybiBILmNFKHYudHlwZVVuaXZlcnNlLEgueksoYS5iKSxiKX0sCkRWOmZ1bmN0aW9uKGEp
+e3JldHVybiBhLmF9LAp5UzpmdW5jdGlvbihhKXtyZXR1cm4gYS5ifSwKbTk6ZnVuY3Rpb24oYSl7dmFy
+IHMscixxLHA9bmV3IEguclQoInNlbGYiLCJyZWNlaXZlciIpLG89Si5FcChPYmplY3QuZ2V0T3duUHJv
+cGVydHlOYW1lcyhwKSx0LlcpCmZvcihzPW8ubGVuZ3RoLHI9MDtyPHM7KytyKXtxPW9bcl0KaWYocFtx
+XT09PWEpcmV0dXJuIHF9dGhyb3cgSC5iKFAueFkoIkZpZWxkIG5hbWUgIithKyIgbm90IGZvdW5kLiIp
+KX0sCm9UOmZ1bmN0aW9uKGEpe2lmKGE9PW51bGwpSC5mTygiYm9vbGVhbiBleHByZXNzaW9uIG11c3Qg
+bm90IGJlIG51bGwiKQpyZXR1cm4gYX0sCmZPOmZ1bmN0aW9uKGEpe3Rocm93IEguYihuZXcgSC5rWShh
+KSl9LAphZzpmdW5jdGlvbihhKXt0aHJvdyBILmIobmV3IFAudDcoYSkpfSwKWWc6ZnVuY3Rpb24oYSl7
+cmV0dXJuIHYuZ2V0SXNvbGF0ZVRhZyhhKX0sCml3OmZ1bmN0aW9uKGEsYixjKXtPYmplY3QuZGVmaW5l
+UHJvcGVydHkoYSxiLHt2YWx1ZTpjLGVudW1lcmFibGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25maWd1
+cmFibGU6dHJ1ZX0pfSwKdzM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuPUguaCgkLk5GLiQxKGEp
+KSxtPSQubndbbl0KaWYobSE9bnVsbCl7T2JqZWN0LmRlZmluZVByb3BlcnR5KGEsdi5kaXNwYXRjaFBy
+b3BlcnR5TmFtZSx7dmFsdWU6bSxlbnVtZXJhYmxlOmZhbHNlLHdyaXRhYmxlOnRydWUsY29uZmlndXJh
+YmxlOnRydWV9KQpyZXR1cm4gbS5pfXM9JC52dltuXQppZihzIT1udWxsKXJldHVybiBzCnI9di5pbnRl
+cmNlcHRvcnNCeVRhZ1tuXQppZihyPT1udWxsKXtxPUguaygkLlRYLiQyKGEsbikpCmlmKHEhPW51bGwp
+e209JC5ud1txXQppZihtIT1udWxsKXtPYmplY3QuZGVmaW5lUHJvcGVydHkoYSx2LmRpc3BhdGNoUHJv
+cGVydHlOYW1lLHt2YWx1ZTptLGVudW1lcmFibGU6ZmFsc2Usd3JpdGFibGU6dHJ1ZSxjb25maWd1cmFi
+bGU6dHJ1ZX0pCnJldHVybiBtLml9cz0kLnZ2W3FdCmlmKHMhPW51bGwpcmV0dXJuIHMKcj12LmludGVy
+Y2VwdG9yc0J5VGFnW3FdCm49cX19aWYocj09bnVsbClyZXR1cm4gbnVsbApzPXIucHJvdG90eXBlCnA9
+blswXQppZihwPT09IiEiKXttPUguVmEocykKJC5ud1tuXT1tCk9iamVjdC5kZWZpbmVQcm9wZXJ0eShh
+LHYuZGlzcGF0Y2hQcm9wZXJ0eU5hbWUse3ZhbHVlOm0sZW51bWVyYWJsZTpmYWxzZSx3cml0YWJsZTp0
+cnVlLGNvbmZpZ3VyYWJsZTp0cnVlfSkKcmV0dXJuIG0uaX1pZihwPT09In4iKXskLnZ2W25dPXMKcmV0
+dXJuIHN9aWYocD09PSItIil7bz1ILlZhKHMpCk9iamVjdC5kZWZpbmVQcm9wZXJ0eShPYmplY3QuZ2V0
+UHJvdG90eXBlT2YoYSksdi5kaXNwYXRjaFByb3BlcnR5TmFtZSx7dmFsdWU6byxlbnVtZXJhYmxlOmZh
+bHNlLHdyaXRhYmxlOnRydWUsY29uZmlndXJhYmxlOnRydWV9KQpyZXR1cm4gby5pfWlmKHA9PT0iKyIp
+cmV0dXJuIEguTGMoYSxzKQppZihwPT09IioiKXRocm93IEguYihQLlNZKG4pKQppZih2LmxlYWZUYWdz
+W25dPT09dHJ1ZSl7bz1ILlZhKHMpCk9iamVjdC5kZWZpbmVQcm9wZXJ0eShPYmplY3QuZ2V0UHJvdG90
+eXBlT2YoYSksdi5kaXNwYXRjaFByb3BlcnR5TmFtZSx7dmFsdWU6byxlbnVtZXJhYmxlOmZhbHNlLHdy
+aXRhYmxlOnRydWUsY29uZmlndXJhYmxlOnRydWV9KQpyZXR1cm4gby5pfWVsc2UgcmV0dXJuIEguTGMo
+YSxzKX0sCkxjOmZ1bmN0aW9uKGEsYil7dmFyIHM9T2JqZWN0LmdldFByb3RvdHlwZU9mKGEpCk9iamVj
+dC5kZWZpbmVQcm9wZXJ0eShzLHYuZGlzcGF0Y2hQcm9wZXJ0eU5hbWUse3ZhbHVlOkouUXUoYixzLG51
+bGwsbnVsbCksZW51bWVyYWJsZTpmYWxzZSx3cml0YWJsZTp0cnVlLGNvbmZpZ3VyYWJsZTp0cnVlfSkK
+cmV0dXJuIGJ9LApWYTpmdW5jdGlvbihhKXtyZXR1cm4gSi5RdShhLCExLG51bGwsISFhLiRpWGopfSwK
+VkY6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPWIucHJvdG90eXBlCmlmKHYubGVhZlRhZ3NbYV09PT10cnVl
+KXJldHVybiBILlZhKHMpCmVsc2UgcmV0dXJuIEouUXUocyxjLG51bGwsbnVsbCl9LApYRDpmdW5jdGlv
+bigpe2lmKCEwPT09JC5CdilyZXR1cm4KJC5Cdj0hMApILloxKCl9LApaMTpmdW5jdGlvbigpe3ZhciBz
+LHIscSxwLG8sbixtLGwKJC5udz1PYmplY3QuY3JlYXRlKG51bGwpCiQudnY9T2JqZWN0LmNyZWF0ZShu
+dWxsKQpILmtPKCkKcz12LmludGVyY2VwdG9yc0J5VGFnCnI9T2JqZWN0LmdldE93blByb3BlcnR5TmFt
+ZXMocykKaWYodHlwZW9mIHdpbmRvdyE9InVuZGVmaW5lZCIpe3dpbmRvdwpxPWZ1bmN0aW9uKCl7fQpm
+b3IocD0wO3A8ci5sZW5ndGg7KytwKXtvPXJbcF0Kbj0kLng3LiQxKG8pCmlmKG4hPW51bGwpe209SC5W
+RihvLHNbb10sbikKaWYobSE9bnVsbCl7T2JqZWN0LmRlZmluZVByb3BlcnR5KG4sdi5kaXNwYXRjaFBy
+b3BlcnR5TmFtZSx7dmFsdWU6bSxlbnVtZXJhYmxlOmZhbHNlLHdyaXRhYmxlOnRydWUsY29uZmlndXJh
+YmxlOnRydWV9KQpxLnByb3RvdHlwZT1ufX19fWZvcihwPTA7cDxyLmxlbmd0aDsrK3Ape289cltwXQpp
+ZigvXltBLVphLXpfXS8udGVzdChvKSl7bD1zW29dCnNbIiEiK29dPWwKc1sifiIrb109bApzWyItIitv
+XT1sCnNbIisiK29dPWwKc1siKiIrb109bH19fSwKa086ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4s
+bT1DLllxKCkKbT1ILnVkKEMuS1UsSC51ZChDLmZRLEgudWQoQy5pNyxILnVkKEMuaTcsSC51ZChDLnhp
+LEgudWQoQy5kayxILnVkKEMud2IoQy5PNCksbSkpKSkpKSkKaWYodHlwZW9mIGRhcnROYXRpdmVEaXNw
+YXRjaEhvb2tzVHJhbnNmb3JtZXIhPSJ1bmRlZmluZWQiKXtzPWRhcnROYXRpdmVEaXNwYXRjaEhvb2tz
+VHJhbnNmb3JtZXIKaWYodHlwZW9mIHM9PSJmdW5jdGlvbiIpcz1bc10KaWYocy5jb25zdHJ1Y3Rvcj09
+QXJyYXkpZm9yKHI9MDtyPHMubGVuZ3RoOysrcil7cT1zW3JdCmlmKHR5cGVvZiBxPT0iZnVuY3Rpb24i
+KW09cShtKXx8bX19cD1tLmdldFRhZwpvPW0uZ2V0VW5rbm93blRhZwpuPW0ucHJvdG90eXBlRm9yVGFn
+CiQuTkY9bmV3IEguZEMocCkKJC5UWD1uZXcgSC53TihvKQokLng3PW5ldyBILlZYKG4pfSwKdWQ6ZnVu
+Y3Rpb24oYSxiKXtyZXR1cm4gYShiKXx8Yn0sCnY0OmZ1bmN0aW9uKGEsYixjLGQsZSxmKXt2YXIgcz1i
+PyJtIjoiIixyPWM/IiI6ImkiLHE9ZD8idSI6IiIscD1lPyJzIjoiIixvPWY/ImciOiIiLG49ZnVuY3Rp
+b24oZyxoKXt0cnl7cmV0dXJuIG5ldyBSZWdFeHAoZyxoKX1jYXRjaChtKXtyZXR1cm4gbX19KGEscyty
+K3ErcCtvKQppZihuIGluc3RhbmNlb2YgUmVnRXhwKXJldHVybiBuCnRocm93IEguYihQLnJyKCJJbGxl
+Z2FsIFJlZ0V4cCBwYXR0ZXJuICgiK1N0cmluZyhuKSsiKSIsYSxudWxsKSl9LApTUTpmdW5jdGlvbihh
+LGIsYyl7dmFyIHMKaWYodHlwZW9mIGI9PSJzdHJpbmciKXJldHVybiBhLmluZGV4T2YoYixjKT49MApl
+bHNlIGlmKGIgaW5zdGFuY2VvZiBILlZSKXtzPUMueEIueW4oYSxjKQpyZXR1cm4gYi5iLnRlc3Qocyl9
+ZWxzZXtzPUouRkwoYixDLnhCLnluKGEsYykpCnJldHVybiFzLmdsMChzKX19LApBNDpmdW5jdGlvbihh
+KXtpZihhLmluZGV4T2YoIiQiLDApPj0wKXJldHVybiBhLnJlcGxhY2UoL1wkL2csIiQkJCQiKQpyZXR1
+cm4gYX0sCmVBOmZ1bmN0aW9uKGEpe2lmKC9bW1xde30oKSorPy5cXF4kfF0vLnRlc3QoYSkpcmV0dXJu
+IGEucmVwbGFjZSgvW1tcXXt9KCkqKz8uXFxeJHxdL2csIlxcJCYiKQpyZXR1cm4gYX0sCnlzOmZ1bmN0
+aW9uKGEsYixjKXt2YXIgcz1ILm5NKGEsYixjKQpyZXR1cm4gc30sCm5NOmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcyxyLHEscAppZihiPT09IiIpe2lmKGE9PT0iIilyZXR1cm4gYwpzPWEubGVuZ3RoCmZvcihyPWMs
+cT0wO3E8czsrK3Epcj1yK2FbcV0rYwpyZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn1wPWEuaW5k
+ZXhPZihiLDApCmlmKHA8MClyZXR1cm4gYQppZihhLmxlbmd0aDw1MDB8fGMuaW5kZXhPZigiJCIsMCk+
+PTApcmV0dXJuIGEuc3BsaXQoYikuam9pbihjKQpyZXR1cm4gYS5yZXBsYWNlKG5ldyBSZWdFeHAoSC5l
+QShiKSwiZyIpLEguQTQoYykpfSwKUEQ6ZnVuY3Rpb24gUEQoYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1i
+fSwKV1U6ZnVuY3Rpb24gV1UoKXt9LApMUDpmdW5jdGlvbiBMUChhLGIsYyxkKXt2YXIgXz10aGlzCl8u
+YT1hCl8uYj1iCl8uYz1jCl8uJHRpPWR9LApYUjpmdW5jdGlvbiBYUihhLGIpe3RoaXMuYT1hCnRoaXMu
+JHRpPWJ9LApMSTpmdW5jdGlvbiBMSShhLGIsYyxkLGUpe3ZhciBfPXRoaXMKXy5hPWEKXy5jPWIKXy5k
+PWMKXy5lPWQKXy5mPWV9LApDajpmdW5jdGlvbiBDaihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhp
+cy5jPWN9LApmOTpmdW5jdGlvbiBmOShhLGIsYyxkLGUsZil7dmFyIF89dGhpcwpfLmE9YQpfLmI9Ygpf
+LmM9YwpfLmQ9ZApfLmU9ZQpfLmY9Zn0sClcwOmZ1bmN0aW9uIFcwKGEsYil7dGhpcy5hPWEKdGhpcy5i
+PWJ9LAphejpmdW5jdGlvbiBheihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LAp2Vjpm
+dW5jdGlvbiB2VihhKXt0aGlzLmE9YX0sCnRlOmZ1bmN0aW9uIHRlKGEpe3RoaXMuYT1hfSwKYnE6ZnVu
+Y3Rpb24gYnEoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sClhPOmZ1bmN0aW9uIFhPKGEpe3RoaXMuYT1h
+CnRoaXMuYj1udWxsfSwKVHA6ZnVuY3Rpb24gVHAoKXt9LApsYzpmdW5jdGlvbiBsYygpe30sCnp4OmZ1
+bmN0aW9uIHp4KCl7fSwKclQ6ZnVuY3Rpb24gclQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkVxOmZ1
+bmN0aW9uIEVxKGEpe3RoaXMuYT1hfSwKa1k6ZnVuY3Rpb24ga1koYSl7dGhpcy5hPWF9LAprcjpmdW5j
+dGlvbiBrcigpe30sCk41OmZ1bmN0aW9uIE41KGEpe3ZhciBfPXRoaXMKXy5hPTAKXy5mPV8uZT1fLmQ9
+Xy5jPV8uYj1udWxsCl8ucj0wCl8uJHRpPWF9LAp2aDpmdW5jdGlvbiB2aChhLGIpe3ZhciBfPXRoaXMK
+Xy5hPWEKXy5iPWIKXy5kPV8uYz1udWxsfSwKaTU6ZnVuY3Rpb24gaTUoYSxiKXt0aGlzLmE9YQp0aGlz
+LiR0aT1ifSwKTjY6ZnVuY3Rpb24gTjYoYSxiLGMpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5kPV8u
+Yz1udWxsCl8uJHRpPWN9LApkQzpmdW5jdGlvbiBkQyhhKXt0aGlzLmE9YX0sCndOOmZ1bmN0aW9uIHdO
+KGEpe3RoaXMuYT1hfSwKVlg6ZnVuY3Rpb24gVlgoYSl7dGhpcy5hPWF9LApWUjpmdW5jdGlvbiBWUihh
+LGIpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5kPV8uYz1udWxsfSwKRUs6ZnVuY3Rpb24gRUsoYSl7
+dGhpcy5iPWF9LApLVzpmdW5jdGlvbiBLVyhhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9
+LApQYjpmdW5jdGlvbiBQYihhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9bnVs
+bH0sCnRROmZ1bmN0aW9uIHRRKGEsYil7dGhpcy5hPWEKdGhpcy5jPWJ9LAp1bjpmdW5jdGlvbiB1bihh
+LGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApTZDpmdW5jdGlvbiBTZChhLGIsYyl7dmFy
+IF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9bnVsbH0sClhGOmZ1bmN0aW9uKGEpe3JldHVybiBh
+fSwKb2Q6ZnVuY3Rpb24oYSxiLGMpe2lmKGE+Pj4wIT09YXx8YT49Yyl0aHJvdyBILmIoSC51KGIsYSkp
+fSwKck06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCmlmKCEoYT4+PjAhPT1hKSlzPWI+Pj4wIT09Ynx8YT5i
+fHxiPmMKZWxzZSBzPSEwCmlmKHMpdGhyb3cgSC5iKEguRHUoYSxiLGMpKQpyZXR1cm4gYn0sCkVUOmZ1
+bmN0aW9uIEVUKCl7fSwKTFo6ZnVuY3Rpb24gTFooKXt9LApEZzpmdW5jdGlvbiBEZygpe30sClBnOmZ1
+bmN0aW9uIFBnKCl7fSwKeGo6ZnVuY3Rpb24geGooKXt9LApkRTpmdW5jdGlvbiBkRSgpe30sClpBOmZ1
+bmN0aW9uIFpBKCl7fSwKZFQ6ZnVuY3Rpb24gZFQoKXt9LApQcTpmdW5jdGlvbiBQcSgpe30sCmVFOmZ1
+bmN0aW9uIGVFKCl7fSwKVjY6ZnVuY3Rpb24gVjYoKXt9LApSRzpmdW5jdGlvbiBSRygpe30sClZQOmZ1
+bmN0aW9uIFZQKCl7fSwKV0I6ZnVuY3Rpb24gV0IoKXt9LApaRzpmdW5jdGlvbiBaRygpe30sCmN6OmZ1
+bmN0aW9uKGEsYil7dmFyIHM9Yi5jCnJldHVybiBzPT1udWxsP2IuYz1ILkIoYSxiLnosITApOnN9LAp4
+WjpmdW5jdGlvbihhLGIpe3ZhciBzPWIuYwpyZXR1cm4gcz09bnVsbD9iLmM9SC5KKGEsImI4IixbYi56
+XSk6c30sClExOmZ1bmN0aW9uKGEpe3ZhciBzPWEueQppZihzPT09Nnx8cz09PTd8fHM9PT04KXJldHVy
+biBILlExKGEueikKcmV0dXJuIHM9PT0xMXx8cz09PTEyfSwKbUQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGEu
+Y3l9LApOMDpmdW5jdGlvbihhKXtyZXR1cm4gSC5FKHYudHlwZVVuaXZlcnNlLGEsITEpfSwKUEw6ZnVu
+Y3Rpb24oYSxiLGEwLGExKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxjPWIueQpz
+d2l0Y2goYyl7Y2FzZSA1OmNhc2UgMTpjYXNlIDI6Y2FzZSAzOmNhc2UgNDpyZXR1cm4gYgpjYXNlIDY6
+cz1iLnoKcj1ILlBMKGEscyxhMCxhMSkKaWYocj09PXMpcmV0dXJuIGIKcmV0dXJuIEguQyhhLHIsITAp
+CmNhc2UgNzpzPWIuegpyPUguUEwoYSxzLGEwLGExKQppZihyPT09cylyZXR1cm4gYgpyZXR1cm4gSC5C
+KGEsciwhMCkKY2FzZSA4OnM9Yi56CnI9SC5QTChhLHMsYTAsYTEpCmlmKHI9PT1zKXJldHVybiBiCnJl
+dHVybiBILmYoYSxyLCEwKQpjYXNlIDk6cT1iLlEKcD1ILmJaKGEscSxhMCxhMSkKaWYocD09PXEpcmV0
+dXJuIGIKcmV0dXJuIEguSihhLGIueixwKQpjYXNlIDEwOm89Yi56Cm49SC5QTChhLG8sYTAsYTEpCm09
+Yi5RCmw9SC5iWihhLG0sYTAsYTEpCmlmKG49PT1vJiZsPT09bSlyZXR1cm4gYgpyZXR1cm4gSC5hKGEs
+bixsKQpjYXNlIDExOms9Yi56Cmo9SC5QTChhLGssYTAsYTEpCmk9Yi5RCmg9SC5xVChhLGksYTAsYTEp
+CmlmKGo9PT1rJiZoPT09aSlyZXR1cm4gYgpyZXR1cm4gSC5kKGEsaixoKQpjYXNlIDEyOmc9Yi5RCmEx
+Kz1nLmxlbmd0aApmPUguYlooYSxnLGEwLGExKQpvPWIuegpuPUguUEwoYSxvLGEwLGExKQppZihmPT09
+ZyYmbj09PW8pcmV0dXJuIGIKcmV0dXJuIEguRChhLG4sZiwhMCkKY2FzZSAxMzplPWIuegppZihlPGEx
+KXJldHVybiBiCmQ9YTBbZS1hMV0KaWYoZD09bnVsbClyZXR1cm4gYgpyZXR1cm4gZApkZWZhdWx0OnRo
+cm93IEguYihQLmhWKCJBdHRlbXB0ZWQgdG8gc3Vic3RpdHV0ZSB1bmV4cGVjdGVkIFJUSSBraW5kICIr
+YykpfX0sCmJaOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG89Yi5sZW5ndGgsbj1bXQpmb3Io
+cz0hMSxyPTA7cjxvOysrcil7cT1iW3JdCnA9SC5QTChhLHEsYyxkKQppZihwIT09cSlzPSEwCm4ucHVz
+aChwKX1yZXR1cm4gcz9uOmJ9LAp2TzpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbT1i
+Lmxlbmd0aCxsPVtdCmZvcihzPSExLHI9MDtyPG07cis9Myl7cT1iW3JdCnA9YltyKzFdCm89YltyKzJd
+Cm49SC5QTChhLG8sYyxkKQppZihuIT09bylzPSEwCmwucHVzaChxKQpsLnB1c2gocCkKbC5wdXNoKG4p
+fXJldHVybiBzP2w6Yn0sCnFUOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9Yi5hLHE9SC5iWihhLHIs
+YyxkKSxwPWIuYixvPUguYlooYSxwLGMsZCksbj1iLmMsbT1ILnZPKGEsbixjLGQpCmlmKHE9PT1yJiZv
+PT09cCYmbT09PW4pcmV0dXJuIGIKcz1uZXcgSC5HKCkKcy5hPXEKcy5iPW8Kcy5jPW0KcmV0dXJuIHN9
+LApRSTpmdW5jdGlvbihhLGIpe2Fbdi5hcnJheVJ0aV09YgpyZXR1cm4gYX0sCkpTOmZ1bmN0aW9uKGEp
+e3ZhciBzPWEuJFMKaWYocyE9bnVsbCl7aWYodHlwZW9mIHM9PSJudW1iZXIiKXJldHVybiBILkJwKHMp
+CnJldHVybiBhLiRTKCl9cmV0dXJuIG51bGx9LApVZTpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKEguUTEo
+YikpaWYoYSBpbnN0YW5jZW9mIEguVHApe3M9SC5KUyhhKQppZihzIT1udWxsKXJldHVybiBzfXJldHVy
+biBILnpLKGEpfSwKeks6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoYSBpbnN0YW5jZW9mIFAuTWgpe3M9YS4k
+dGkKcmV0dXJuIHMhPW51bGw/czpILlZVKGEpfWlmKEFycmF5LmlzQXJyYXkoYSkpcmV0dXJuIEgudDYo
+YSkKcmV0dXJuIEguVlUoSi5pYShhKSl9LAp0NjpmdW5jdGlvbihhKXt2YXIgcz1hW3YuYXJyYXlSdGld
+LHI9dC5iCmlmKHM9PW51bGwpcmV0dXJuIHIKaWYocy5jb25zdHJ1Y3RvciE9PXIuY29uc3RydWN0b3Ip
+cmV0dXJuIHIKcmV0dXJuIHN9LApMaDpmdW5jdGlvbihhKXt2YXIgcz1hLiR0aQpyZXR1cm4gcyE9bnVs
+bD9zOkguVlUoYSl9LApWVTpmdW5jdGlvbihhKXt2YXIgcz1hLmNvbnN0cnVjdG9yLHI9cy4kY2NhY2hl
+CmlmKHIhPW51bGwpcmV0dXJuIHIKcmV0dXJuIEgucjkoYSxzKX0sCnI5OmZ1bmN0aW9uKGEsYil7dmFy
+IHM9YSBpbnN0YW5jZW9mIEguVHA/YS5fX3Byb3RvX18uX19wcm90b19fLmNvbnN0cnVjdG9yOmIscj1I
+LmFpKHYudHlwZVVuaXZlcnNlLHMubmFtZSkKYi4kY2NhY2hlPXIKcmV0dXJuIHJ9LApCcDpmdW5jdGlv
+bihhKXt2YXIgcyxyLHEKSC51UChhKQpzPXYudHlwZXMKcj1zW2FdCmlmKHR5cGVvZiByPT0ic3RyaW5n
+Iil7cT1ILkUodi50eXBlVW5pdmVyc2UsciwhMSkKc1thXT1xCnJldHVybiBxfXJldHVybiByfSwKS3g6
+ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9YS54CmlmKHAhPW51bGwpcmV0dXJuIHAKcz1hLmN5CnI9cy5y
+ZXBsYWNlKC9cKi9nLCIiKQppZihyPT09cylyZXR1cm4gYS54PW5ldyBILmxZKGEpCnE9SC5FKHYudHlw
+ZVVuaXZlcnNlLHIsITApCnA9cS54CnJldHVybiBhLng9cD09bnVsbD9xLng9bmV3IEgubFkocSk6cH0s
+CkpKOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMsbz10LksKaWYocD09PW8pcmV0dXJuIEguUkUo
+cCxhLEgua2UpCmlmKCFILkE4KHApKWlmKCEocD09PXQuXykpbz1wPT09bwplbHNlIG89ITAKZWxzZSBv
+PSEwCmlmKG8pcmV0dXJuIEguUkUocCxhLEguSXcpCm89cC55CnM9bz09PTY/cC56OnAKaWYocz09PXQu
+UylyPUgub2sKZWxzZSBpZihzPT09dC5nUnx8cz09PXQuZGkpcj1ILktICmVsc2UgaWYocz09PXQuTily
+PUguTU0KZWxzZSByPXM9PT10Lnk/SC5yUTpudWxsCmlmKHIhPW51bGwpcmV0dXJuIEguUkUocCxhLHIp
+CmlmKHMueT09PTkpe3E9cy56CmlmKHMuUS5ldmVyeShILmNjKSl7cC5yPSIkaSIrcQppZihxPT09InpN
+IilyZXR1cm4gSC5SRShwLGEsSC55TSkKcmV0dXJuIEguUkUocCxhLEgudDQpfX1lbHNlIGlmKG89PT03
+KXJldHVybiBILlJFKHAsYSxILkFRKQpyZXR1cm4gSC5SRShwLGEsSC5ZTyl9LApSRTpmdW5jdGlvbihh
+LGIsYyl7YS5iPWMKcmV0dXJuIGEuYihiKX0sCkF1OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzCmlm
+KCFILkE4KHEpKWlmKCEocT09PXQuXykpcz1xPT09dC5LCmVsc2Ugcz0hMAplbHNlIHM9ITAKaWYocyly
+PUguaG4KZWxzZSBpZihxPT09dC5LKXI9SC5UaQplbHNlIHI9SC5sNApxLmE9cgpyZXR1cm4gcS5hKGEp
+fSwKUWo6ZnVuY3Rpb24oYSl7dmFyIHMscj1hLnkKaWYoIUguQTgoYSkpaWYoIShhPT09dC5fKSlpZigh
+KGE9PT10LmNGKSlpZihyIT09NylzPXI9PT04JiZILlFqKGEueil8fGE9PT10LlB8fGE9PT10LlQKZWxz
+ZSBzPSEwCmVsc2Ugcz0hMAplbHNlIHM9ITAKZWxzZSBzPSEwCnJldHVybiBzfSwKWU86ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcwppZihhPT1udWxsKXJldHVybiBILlFqKHMpCnJldHVybiBILldlKHYudHlwZVVu
+aXZlcnNlLEguVWUoYSxzKSxudWxsLHMsbnVsbCl9LApBUTpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJl
+dHVybiEwCnJldHVybiB0aGlzLnouYihhKX0sCnQ0OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcwppZihh
+PT1udWxsKXJldHVybiBILlFqKHIpCnM9ci5yCmlmKGEgaW5zdGFuY2VvZiBQLk1oKXJldHVybiEhYVtz
+XQpyZXR1cm4hIUouaWEoYSlbc119LAp5TTpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMKaWYoYT09bnVs
+bClyZXR1cm4gSC5RaihyKQppZih0eXBlb2YgYSE9Im9iamVjdCIpcmV0dXJuITEKaWYoQXJyYXkuaXNB
+cnJheShhKSlyZXR1cm4hMApzPXIucgppZihhIGluc3RhbmNlb2YgUC5NaClyZXR1cm4hIWFbc10KcmV0
+dXJuISFKLmlhKGEpW3NdfSwKT3o6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwppZihhPT1udWxsKXJldHVy
+biBhCmVsc2UgaWYocy5iKGEpKXJldHVybiBhCkgubTQoYSxzKX0sCmw0OmZ1bmN0aW9uKGEpe3ZhciBz
+PXRoaXMKaWYoYT09bnVsbClyZXR1cm4gYQplbHNlIGlmKHMuYihhKSlyZXR1cm4gYQpILm00KGEscyl9
+LAptNDpmdW5jdGlvbihhLGIpe3Rocm93IEguYihILlpjKEguV0soYSxILlVlKGEsYiksSC5kbShiLG51
+bGwpKSkpfSwKRGg6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9bnVsbAppZihILldlKHYudHlwZVVuaXZl
+cnNlLGEscyxiLHMpKXJldHVybiBhCnRocm93IEguYihILlpjKCJUaGUgdHlwZSBhcmd1bWVudCAnIitI
+LkVqKEguZG0oYSxzKSkrIicgaXMgbm90IGEgc3VidHlwZSBvZiB0aGUgdHlwZSB2YXJpYWJsZSBib3Vu
+ZCAnIitILkVqKEguZG0oYixzKSkrIicgb2YgdHlwZSB2YXJpYWJsZSAnIitILkVqKGMpKyInIGluICci
+K0guRWooZCkrIicuIikpfSwKV0s6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPVAuaGwoYSkscj1ILmRtKGI9
+PW51bGw/SC56SyhhKTpiLG51bGwpCnJldHVybiBzKyI6IHR5cGUgJyIrSC5FaihyKSsiJyBpcyBub3Qg
+YSBzdWJ0eXBlIG9mIHR5cGUgJyIrSC5FaihjKSsiJyJ9LApaYzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3
+IEguaU0oIlR5cGVFcnJvcjogIithKX0sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguaU0oIlR5
+cGVFcnJvcjogIitILldLKGEsbnVsbCxiKSl9LAprZTpmdW5jdGlvbihhKXtyZXR1cm4gYSE9bnVsbH0s
+ClRpOmZ1bmN0aW9uKGEpe3JldHVybiBhfSwKSXc6ZnVuY3Rpb24oYSl7cmV0dXJuITB9LApobjpmdW5j
+dGlvbihhKXtyZXR1cm4gYX0sCnJROmZ1bmN0aW9uKGEpe3JldHVybiEwPT09YXx8ITE9PT1hfSwKcDg6
+ZnVuY3Rpb24oYSl7aWYoITA9PT1hKXJldHVybiEwCmlmKCExPT09YSlyZXR1cm4hMQp0aHJvdyBILmIo
+SC5xKGEsImJvb2wiKSl9LAp5ODpmdW5jdGlvbihhKXtpZighMD09PWEpcmV0dXJuITAKaWYoITE9PT1h
+KXJldHVybiExCmlmKGE9PW51bGwpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJib29sIikpfSwKZHA6
+ZnVuY3Rpb24oYSl7aWYoITA9PT1hKXJldHVybiEwCmlmKCExPT09YSlyZXR1cm4hMQppZihhPT1udWxs
+KXJldHVybiBhCnRocm93IEguYihILnEoYSwiYm9vbD8iKSl9LApGRzpmdW5jdGlvbihhKXtpZih0eXBl
+b2YgYT09Im51bWJlciIpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJkb3VibGUiKSl9LApHSDpmdW5j
+dGlvbihhKXtpZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKaWYoYT09bnVsbClyZXR1cm4gYQp0
+aHJvdyBILmIoSC5xKGEsImRvdWJsZSIpKX0sClFrOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVt
+YmVyIilyZXR1cm4gYQppZihhPT1udWxsKXJldHVybiBhCnRocm93IEguYihILnEoYSwiZG91YmxlPyIp
+KX0sCm9rOmZ1bmN0aW9uKGEpe3JldHVybiB0eXBlb2YgYT09Im51bWJlciImJk1hdGguZmxvb3IoYSk9
+PT1hfSwKSVo6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiJiZNYXRoLmZsb29yKGEpPT09
+YSlyZXR1cm4gYQp0aHJvdyBILmIoSC5xKGEsImludCIpKX0sCnVQOmZ1bmN0aW9uKGEpe2lmKHR5cGVv
+ZiBhPT0ibnVtYmVyIiYmTWF0aC5mbG9vcihhKT09PWEpcmV0dXJuIGEKaWYoYT09bnVsbClyZXR1cm4g
+YQp0aHJvdyBILmIoSC5xKGEsImludCIpKX0sClVjOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVt
+YmVyIiYmTWF0aC5mbG9vcihhKT09PWEpcmV0dXJuIGEKaWYoYT09bnVsbClyZXR1cm4gYQp0aHJvdyBI
+LmIoSC5xKGEsImludD8iKSl9LApLSDpmdW5jdGlvbihhKXtyZXR1cm4gdHlwZW9mIGE9PSJudW1iZXIi
+fSwKejU6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiKXJldHVybiBhCnRocm93IEguYihI
+LnEoYSwibnVtIikpfSwKVzE6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiKXJldHVybiBh
+CmlmKGE9PW51bGwpcmV0dXJuIGEKdGhyb3cgSC5iKEgucShhLCJudW0iKSl9LApjVTpmdW5jdGlvbihh
+KXtpZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKaWYoYT09bnVsbClyZXR1cm4gYQp0aHJvdyBI
+LmIoSC5xKGEsIm51bT8iKSl9LApNTTpmdW5jdGlvbihhKXtyZXR1cm4gdHlwZW9mIGE9PSJzdHJpbmci
+fSwKQnQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBhCnRocm93IEguYihI
+LnEoYSwiU3RyaW5nIikpfSwKaDpmdW5jdGlvbihhKXtpZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJu
+IGEKaWYoYT09bnVsbClyZXR1cm4gYQp0aHJvdyBILmIoSC5xKGEsIlN0cmluZyIpKX0sCms6ZnVuY3Rp
+b24oYSl7aWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBhCmlmKGE9PW51bGwpcmV0dXJuIGEKdGhy
+b3cgSC5iKEgucShhLCJTdHJpbmc/IikpfSwKaW86ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKZm9yKHM9
+IiIscj0iIixxPTA7cTxhLmxlbmd0aDsrK3Escj0iLCAiKXMrPUMueEIuaChyLEguZG0oYVtxXSxiKSkK
+cmV0dXJuIHN9LApiSTpmdW5jdGlvbihhNSxhNixhNyl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxo
+LGcsZixlLGQsYyxiLGEsYTAsYTEsYTIsYTMsYTQ9IiwgIgppZihhNyE9bnVsbCl7cz1hNy5sZW5ndGgK
+aWYoYTY9PW51bGwpe2E2PUguUUkoW10sdC5zKQpyPW51bGx9ZWxzZSByPWE2Lmxlbmd0aApxPWE2Lmxl
+bmd0aApmb3IocD1zO3A+MDstLXApQy5ObS5pKGE2LCJUIisocStwKSkKZm9yKG89dC5XLG49dC5fLG09
+dC5LLGw9IjwiLGs9IiIscD0wO3A8czsrK3Asaz1hNCl7bCs9awpqPWE2Lmxlbmd0aAppPWotMS1wCmlm
+KGk8MClyZXR1cm4gSC5PSChhNixpKQpsPUMueEIuaChsLGE2W2ldKQpoPWE3W3BdCmc9aC55CmlmKCEo
+Zz09PTJ8fGc9PT0zfHxnPT09NHx8Zz09PTV8fGg9PT1vKSlpZighKGg9PT1uKSlqPWg9PT1tCmVsc2Ug
+aj0hMAplbHNlIGo9ITAKaWYoIWopbCs9Qy54Qi5oKCIgZXh0ZW5kcyAiLEguZG0oaCxhNikpfWwrPSI+
+In1lbHNle2w9IiIKcj1udWxsfW89YTUuegpmPWE1LlEKZT1mLmEKZD1lLmxlbmd0aApjPWYuYgpiPWMu
+bGVuZ3RoCmE9Zi5jCmEwPWEubGVuZ3RoCmExPUguZG0obyxhNikKZm9yKGEyPSIiLGEzPSIiLHA9MDtw
+PGQ7KytwLGEzPWE0KWEyKz1DLnhCLmgoYTMsSC5kbShlW3BdLGE2KSkKaWYoYj4wKXthMis9YTMrIlsi
+CmZvcihhMz0iIixwPTA7cDxiOysrcCxhMz1hNClhMis9Qy54Qi5oKGEzLEguZG0oY1twXSxhNikpCmEy
+Kz0iXSJ9aWYoYTA+MCl7YTIrPWEzKyJ7Igpmb3IoYTM9IiIscD0wO3A8YTA7cCs9MyxhMz1hNCl7YTIr
+PWEzCmlmKGFbcCsxXSlhMis9InJlcXVpcmVkICIKYTIrPUoucGIoSC5kbShhW3ArMl0sYTYpLCIgIikr
+YVtwXX1hMis9In0ifWlmKHIhPW51bGwpe2E2LnRvU3RyaW5nCmE2Lmxlbmd0aD1yfXJldHVybiBsKyIo
+IithMisiKSA9PiAiK0guRWooYTEpfSwKZG06ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxs
+PWEueQppZihsPT09NSlyZXR1cm4iZXJhc2VkIgppZihsPT09MilyZXR1cm4iZHluYW1pYyIKaWYobD09
+PTMpcmV0dXJuInZvaWQiCmlmKGw9PT0xKXJldHVybiJOZXZlciIKaWYobD09PTQpcmV0dXJuImFueSIK
+aWYobD09PTYpe3M9SC5kbShhLnosYikKcmV0dXJuIHN9aWYobD09PTcpe3I9YS56CnM9SC5kbShyLGIp
+CnE9ci55CnJldHVybiBKLnBiKHE9PT0xMXx8cT09PTEyP0MueEIuaCgiKCIscykrIikiOnMsIj8iKX1p
+ZihsPT09OClyZXR1cm4iRnV0dXJlT3I8IitILkVqKEguZG0oYS56LGIpKSsiPiIKaWYobD09PTkpe3A9
+SC5vMyhhLnopCm89YS5RCnJldHVybiBvLmxlbmd0aCE9PTA/cCsoIjwiK0guaW8obyxiKSsiPiIpOnB9
+aWYobD09PTExKXJldHVybiBILmJJKGEsYixudWxsKQppZihsPT09MTIpcmV0dXJuIEguYkkoYS56LGIs
+YS5RKQppZihsPT09MTMpe2IudG9TdHJpbmcKbj1hLnoKbT1iLmxlbmd0aApuPW0tMS1uCmlmKG48MHx8
+bj49bSlyZXR1cm4gSC5PSChiLG4pCnJldHVybiBiW25dfXJldHVybiI/In0sCm8zOmZ1bmN0aW9uKGEp
+e3ZhciBzLHI9di5tYW5nbGVkR2xvYmFsTmFtZXNbYV0KaWYociE9bnVsbClyZXR1cm4gcgpzPSJtaW5p
+ZmllZDoiK2EKcmV0dXJuIHN9LApRbzpmdW5jdGlvbihhLGIpe3ZhciBzPWEudFJbYl0KZm9yKDt0eXBl
+b2Ygcz09InN0cmluZyI7KXM9YS50UltzXQpyZXR1cm4gc30sCmFpOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxLHAsbyxuPWEuZVQsbT1uW2JdCmlmKG09PW51bGwpcmV0dXJuIEguRShhLGIsITEpCmVsc2UgaWYo
+dHlwZW9mIG09PSJudW1iZXIiKXtzPW0Kcj1ILm0oYSw1LCIjIikKcT1bXQpmb3IocD0wO3A8czsrK3Ap
+cS5wdXNoKHIpCm89SC5KKGEsYixxKQpuW2JdPW8KcmV0dXJuIG99ZWxzZSByZXR1cm4gbX0sCnhiOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIEguSXgoYS50UixiKX0sCkZGOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEgu
+SXgoYS5lVCxiKX0sCkU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9YS5lQyxxPXIuZ2V0KGIpCmlmKHEh
+PW51bGwpcmV0dXJuIHEKcz1ILmkoSC5vKGEsbnVsbCxiLGMpKQpyLnNldChiLHMpCnJldHVybiBzfSwK
+Y0U6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscT1iLmNoCmlmKHE9PW51bGwpcT1iLmNoPW5ldyBNYXAo
+KQpzPXEuZ2V0KGMpCmlmKHMhPW51bGwpcmV0dXJuIHMKcj1ILmkoSC5vKGEsYixjLCEwKSkKcS5zZXQo
+YyxyKQpyZXR1cm4gcn0sCnY1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscD1iLmN4CmlmKHA9PW51
+bGwpcD1iLmN4PW5ldyBNYXAoKQpzPWMuY3kKcj1wLmdldChzKQppZihyIT1udWxsKXJldHVybiByCnE9
+SC5hKGEsYixjLnk9PT0xMD9jLlE6W2NdKQpwLnNldChzLHEpCnJldHVybiBxfSwKQkQ6ZnVuY3Rpb24o
+YSxiKXtiLmE9SC5BdQpiLmI9SC5KSgpyZXR1cm4gYn0sCm06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIs
+cT1hLmVDLmdldChjKQppZihxIT1udWxsKXJldHVybiBxCnM9bmV3IEguSmMobnVsbCxudWxsKQpzLnk9
+YgpzLmN5PWMKcj1ILkJEKGEscykKYS5lQy5zZXQoYyxyKQpyZXR1cm4gcn0sCkM6ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBzLHI9Yi5jeSsiKiIscT1hLmVDLmdldChyKQppZihxIT1udWxsKXJldHVybiBxCnM9SC5a
+NyhhLGIscixjKQphLmVDLnNldChyLHMpCnJldHVybiBzfSwKWjc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFy
+IHMscixxCmlmKGQpe3M9Yi55CmlmKCFILkE4KGIpKXI9Yj09PXQuUHx8Yj09PXQuVHx8cz09PTd8fHM9
+PT02CmVsc2Ugcj0hMAppZihyKXJldHVybiBifXE9bmV3IEguSmMobnVsbCxudWxsKQpxLnk9NgpxLno9
+YgpxLmN5PWMKcmV0dXJuIEguQkQoYSxxKX0sCkI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9Yi5jeSsi
+PyIscT1hLmVDLmdldChyKQppZihxIT1udWxsKXJldHVybiBxCnM9SC5sbChhLGIscixjKQphLmVDLnNl
+dChyLHMpCnJldHVybiBzfSwKbGw6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAKaWYoZCl7cz1i
+LnkKaWYoIUguQTgoYikpaWYoIShiPT09dC5QfHxiPT09dC5UKSlpZihzIT09NylyPXM9PT04JiZILmxS
+KGIueikKZWxzZSByPSEwCmVsc2Ugcj0hMAplbHNlIHI9ITAKaWYocilyZXR1cm4gYgplbHNlIGlmKHM9
+PT0xfHxiPT09dC5jRilyZXR1cm4gdC5QCmVsc2UgaWYocz09PTYpe3E9Yi56CmlmKHEueT09PTgmJkgu
+bFIocS56KSlyZXR1cm4gcQplbHNlIHJldHVybiBILmN6KGEsYil9fXA9bmV3IEguSmMobnVsbCxudWxs
+KQpwLnk9NwpwLno9YgpwLmN5PWMKcmV0dXJuIEguQkQoYSxwKX0sCmY6ZnVuY3Rpb24oYSxiLGMpe3Zh
+ciBzLHI9Yi5jeSsiLyIscT1hLmVDLmdldChyKQppZihxIT1udWxsKXJldHVybiBxCnM9SC5lVihhLGIs
+cixjKQphLmVDLnNldChyLHMpCnJldHVybiBzfSwKZVY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixx
+CmlmKGQpe3M9Yi55CmlmKCFILkE4KGIpKWlmKCEoYj09PXQuXykpcj1iPT09dC5LCmVsc2Ugcj0hMApl
+bHNlIHI9ITAKaWYocnx8Yj09PXQuSylyZXR1cm4gYgplbHNlIGlmKHM9PT0xKXJldHVybiBILkooYSwi
+YjgiLFtiXSkKZWxzZSBpZihiPT09dC5QfHxiPT09dC5UKXJldHVybiB0LmJHfXE9bmV3IEguSmMobnVs
+bCxudWxsKQpxLnk9OApxLno9YgpxLmN5PWMKcmV0dXJuIEguQkQoYSxxKX0sCkg6ZnVuY3Rpb24oYSxi
+KXt2YXIgcyxyLHE9IiIrYisiXiIscD1hLmVDLmdldChxKQppZihwIT1udWxsKXJldHVybiBwCnM9bmV3
+IEguSmMobnVsbCxudWxsKQpzLnk9MTMKcy56PWIKcy5jeT1xCnI9SC5CRChhLHMpCmEuZUMuc2V0KHEs
+cikKcmV0dXJuIHJ9LApVeDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLmxlbmd0aApmb3Iocz0iIixy
+PSIiLHE9MDtxPHA7KytxLHI9IiwiKXMrPXIrYVtxXS5jeQpyZXR1cm4gc30sClM0OmZ1bmN0aW9uKGEp
+e3ZhciBzLHIscSxwLG8sbixtPWEubGVuZ3RoCmZvcihzPSIiLHI9IiIscT0wO3E8bTtxKz0zLHI9Iiwi
+KXtwPWFbcV0Kbz1hW3ErMV0/IiEiOiI6IgpuPWFbcSsyXS5jeQpzKz1yK3ArbytufXJldHVybiBzfSwK
+SjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHA9YgppZihjLmxlbmd0aCE9PTApcCs9IjwiK0guVXgo
+YykrIj4iCnM9YS5lQy5nZXQocCkKaWYocyE9bnVsbClyZXR1cm4gcwpyPW5ldyBILkpjKG51bGwsbnVs
+bCkKci55PTkKci56PWIKci5RPWMKaWYoYy5sZW5ndGg+MClyLmM9Y1swXQpyLmN5PXAKcT1ILkJEKGEs
+cikKYS5lQy5zZXQocCxxKQpyZXR1cm4gcX0sCmE6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwLG8s
+bgppZihiLnk9PT0xMCl7cz1iLnoKcj1iLlEuY29uY2F0KGMpfWVsc2V7cj1jCnM9Yn1xPXMuY3krKCI7
+PCIrSC5VeChyKSsiPiIpCnA9YS5lQy5nZXQocSkKaWYocCE9bnVsbClyZXR1cm4gcApvPW5ldyBILkpj
+KG51bGwsbnVsbCkKby55PTEwCm8uej1zCm8uUT1yCm8uY3k9cQpuPUguQkQoYSxvKQphLmVDLnNldChx
+LG4pCnJldHVybiBufSwKZDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuPWIuY3ksbT1jLmEs
+bD1tLmxlbmd0aCxrPWMuYixqPWsubGVuZ3RoLGk9Yy5jLGg9aS5sZW5ndGgsZz0iKCIrSC5VeChtKQpp
+ZihqPjApe3M9bD4wPyIsIjoiIgpyPUguVXgoaykKZys9cysiWyIrcisiXSJ9aWYoaD4wKXtzPWw+MD8i
+LCI6IiIKcj1ILlM0KGkpCmcrPXMrInsiK3IrIn0ifXE9bisoZysiKSIpCnA9YS5lQy5nZXQocSkKaWYo
+cCE9bnVsbClyZXR1cm4gcApvPW5ldyBILkpjKG51bGwsbnVsbCkKby55PTExCm8uej1iCm8uUT1jCm8u
+Y3k9cQpyPUguQkQoYSxvKQphLmVDLnNldChxLHIpCnJldHVybiByfSwKRDpmdW5jdGlvbihhLGIsYyxk
+KXt2YXIgcyxyPWIuY3krKCI8IitILlV4KGMpKyI+IikscT1hLmVDLmdldChyKQppZihxIT1udWxsKXJl
+dHVybiBxCnM9SC5odyhhLGIsYyxyLGQpCmEuZUMuc2V0KHIscykKcmV0dXJuIHN9LApodzpmdW5jdGlv
+bihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8sbixtLGwKaWYoZSl7cz1jLmxlbmd0aApyPW5ldyBBcnJh
+eShzKQpmb3IocT0wLHA9MDtwPHM7KytwKXtvPWNbcF0KaWYoby55PT09MSl7cltwXT1vOysrcX19aWYo
+cT4wKXtuPUguUEwoYSxiLHIsMCkKbT1ILmJaKGEsYyxyLDApCnJldHVybiBILkQoYSxuLG0sYyE9PW0p
+fX1sPW5ldyBILkpjKG51bGwsbnVsbCkKbC55PTEyCmwuej1iCmwuUT1jCmwuY3k9ZApyZXR1cm4gSC5C
+RChhLGwpfSwKbzpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm57dTphLGU6YixyOmMsczpbXSxwOjAsbjpk
+fX0sCmk6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGc9YS5yLGY9YS5zCmZv
+cihzPWcubGVuZ3RoLHI9MDtyPHM7KXtxPWcuY2hhckNvZGVBdChyKQppZihxPj00OCYmcTw9NTcpcj1I
+LkEocisxLHEsZyxmKQplbHNlIGlmKCgoKHF8MzIpPj4+MCktOTcmNjU1MzUpPDI2fHxxPT09OTV8fHE9
+PT0zNilyPUgudChhLHIsZyxmLCExKQplbHNlIGlmKHE9PT00NilyPUgudChhLHIsZyxmLCEwKQplbHNl
+eysrcgpzd2l0Y2gocSl7Y2FzZSA0NDpicmVhawpjYXNlIDU4OmYucHVzaCghMSkKYnJlYWsKY2FzZSAz
+MzpmLnB1c2goITApCmJyZWFrCmNhc2UgNTk6Zi5wdXNoKEguSyhhLnUsYS5lLGYucG9wKCkpKQpicmVh
+awpjYXNlIDk0OmYucHVzaChILkgoYS51LGYucG9wKCkpKQpicmVhawpjYXNlIDM1OmYucHVzaChILm0o
+YS51LDUsIiMiKSkKYnJlYWsKY2FzZSA2NDpmLnB1c2goSC5tKGEudSwyLCJAIikpCmJyZWFrCmNhc2Ug
+MTI2OmYucHVzaChILm0oYS51LDMsIn4iKSkKYnJlYWsKY2FzZSA2MDpmLnB1c2goYS5wKQphLnA9Zi5s
+ZW5ndGgKYnJlYWsKY2FzZSA2MjpwPWEudQpvPWYuc3BsaWNlKGEucCkKSC5yKGEudSxhLmUsbykKYS5w
+PWYucG9wKCkKbj1mLnBvcCgpCmlmKHR5cGVvZiBuPT0ic3RyaW5nIilmLnB1c2goSC5KKHAsbixvKSkK
+ZWxzZXttPUguSyhwLGEuZSxuKQpzd2l0Y2gobS55KXtjYXNlIDExOmYucHVzaChILkQocCxtLG8sYS5u
+KSkKYnJlYWsKZGVmYXVsdDpmLnB1c2goSC5hKHAsbSxvKSkKYnJlYWt9fWJyZWFrCmNhc2UgMzg6SC5J
+KGEsZikKYnJlYWsKY2FzZSA0MjpsPWEudQpmLnB1c2goSC5DKGwsSC5LKGwsYS5lLGYucG9wKCkpLGEu
+bikpCmJyZWFrCmNhc2UgNjM6bD1hLnUKZi5wdXNoKEguQihsLEguSyhsLGEuZSxmLnBvcCgpKSxhLm4p
+KQpicmVhawpjYXNlIDQ3Omw9YS51CmYucHVzaChILmYobCxILksobCxhLmUsZi5wb3AoKSksYS5uKSkK
+YnJlYWsKY2FzZSA0MDpmLnB1c2goYS5wKQphLnA9Zi5sZW5ndGgKYnJlYWsKY2FzZSA0MTpwPWEudQpr
+PW5ldyBILkcoKQpqPXAuc0VBCmk9cC5zRUEKbj1mLnBvcCgpCmlmKHR5cGVvZiBuPT0ibnVtYmVyIilz
+d2l0Y2gobil7Y2FzZS0xOmo9Zi5wb3AoKQpicmVhawpjYXNlLTI6aT1mLnBvcCgpCmJyZWFrCmRlZmF1
+bHQ6Zi5wdXNoKG4pCmJyZWFrfWVsc2UgZi5wdXNoKG4pCm89Zi5zcGxpY2UoYS5wKQpILnIoYS51LGEu
+ZSxvKQphLnA9Zi5wb3AoKQprLmE9bwprLmI9agprLmM9aQpmLnB1c2goSC5kKHAsSC5LKHAsYS5lLGYu
+cG9wKCkpLGspKQpicmVhawpjYXNlIDkxOmYucHVzaChhLnApCmEucD1mLmxlbmd0aApicmVhawpjYXNl
+IDkzOm89Zi5zcGxpY2UoYS5wKQpILnIoYS51LGEuZSxvKQphLnA9Zi5wb3AoKQpmLnB1c2gobykKZi5w
+dXNoKC0xKQpicmVhawpjYXNlIDEyMzpmLnB1c2goYS5wKQphLnA9Zi5sZW5ndGgKYnJlYWsKY2FzZSAx
+MjU6bz1mLnNwbGljZShhLnApCkgueShhLnUsYS5lLG8pCmEucD1mLnBvcCgpCmYucHVzaChvKQpmLnB1
+c2goLTIpCmJyZWFrCmRlZmF1bHQ6dGhyb3ciQmFkIGNoYXJhY3RlciAiK3F9fX1oPWYucG9wKCkKcmV0
+dXJuIEguSyhhLnUsYS5lLGgpfSwKQTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHE9Yi00OApmb3Io
+cz1jLmxlbmd0aDthPHM7KythKXtyPWMuY2hhckNvZGVBdChhKQppZighKHI+PTQ4JiZyPD01NykpYnJl
+YWsKcT1xKjEwKyhyLTQ4KX1kLnB1c2gocSkKcmV0dXJuIGF9LAp0OmZ1bmN0aW9uKGEsYixjLGQsZSl7
+dmFyIHMscixxLHAsbyxuLG09YisxCmZvcihzPWMubGVuZ3RoO208czsrK20pe3I9Yy5jaGFyQ29kZUF0
+KG0pCmlmKHI9PT00Nil7aWYoZSlicmVhawplPSEwfWVsc2V7aWYoISgoKChyfDMyKT4+PjApLTk3JjY1
+NTM1KTwyNnx8cj09PTk1fHxyPT09MzYpKXE9cj49NDgmJnI8PTU3CmVsc2UgcT0hMAppZighcSlicmVh
+a319cD1jLnN1YnN0cmluZyhiLG0pCmlmKGUpe3M9YS51Cm89YS5lCmlmKG8ueT09PTEwKW89by56Cm49
+SC5RbyhzLG8ueilbcF0KaWYobj09bnVsbClILnYoJ05vICInK3ArJyIgaW4gIicrSC5tRChvKSsnIicp
+CmQucHVzaChILmNFKHMsbyxuKSl9ZWxzZSBkLnB1c2gocCkKcmV0dXJuIG19LApJOmZ1bmN0aW9uKGEs
+Yil7dmFyIHM9Yi5wb3AoKQppZigwPT09cyl7Yi5wdXNoKEgubShhLnUsMSwiMCYiKSkKcmV0dXJufWlm
+KDE9PT1zKXtiLnB1c2goSC5tKGEudSw0LCIxJiIpKQpyZXR1cm59dGhyb3cgSC5iKFAuaFYoIlVuZXhw
+ZWN0ZWQgZXh0ZW5kZWQgb3BlcmF0aW9uICIrSC5FaihzKSkpfSwKSzpmdW5jdGlvbihhLGIsYyl7aWYo
+dHlwZW9mIGM9PSJzdHJpbmciKXJldHVybiBILkooYSxjLGEuc0VBKQplbHNlIGlmKHR5cGVvZiBjPT0i
+bnVtYmVyIilyZXR1cm4gSC5UVihhLGIsYykKZWxzZSByZXR1cm4gY30sCnI6ZnVuY3Rpb24oYSxiLGMp
+e3ZhciBzLHI9Yy5sZW5ndGgKZm9yKHM9MDtzPHI7KytzKWNbc109SC5LKGEsYixjW3NdKX0sCnk6ZnVu
+Y3Rpb24oYSxiLGMpe3ZhciBzLHI9Yy5sZW5ndGgKZm9yKHM9MjtzPHI7cys9MyljW3NdPUguSyhhLGIs
+Y1tzXSl9LApUVjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxPWIueQppZihxPT09MTApe2lmKGM9PT0w
+KXJldHVybiBiLnoKcz1iLlEKcj1zLmxlbmd0aAppZihjPD1yKXJldHVybiBzW2MtMV0KYy09cgpiPWIu
+egpxPWIueX1lbHNlIGlmKGM9PT0wKXJldHVybiBiCmlmKHEhPT05KXRocm93IEguYihQLmhWKCJJbmRl
+eGVkIGJhc2UgbXVzdCBiZSBhbiBpbnRlcmZhY2UgdHlwZSIpKQpzPWIuUQppZihjPD1zLmxlbmd0aCly
+ZXR1cm4gc1tjLTFdCnRocm93IEguYihQLmhWKCJCYWQgaW5kZXggIitjKyIgZm9yICIrYi53KDApKSl9
+LApXZTpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqCmlmKGI9PT1kKXJl
+dHVybiEwCmlmKCFILkE4KGQpKWlmKCEoZD09PXQuXykpcz1kPT09dC5LCmVsc2Ugcz0hMAplbHNlIHM9
+ITAKaWYocylyZXR1cm4hMApyPWIueQppZihyPT09NClyZXR1cm4hMAppZihILkE4KGIpKXJldHVybiEx
+CmlmKGIueSE9PTEpcz1iPT09dC5QfHxiPT09dC5UCmVsc2Ugcz0hMAppZihzKXJldHVybiEwCnE9cj09
+PTEzCmlmKHEpaWYoSC5XZShhLGNbYi56XSxjLGQsZSkpcmV0dXJuITAKcD1kLnkKaWYocj09PTYpcmV0
+dXJuIEguV2UoYSxiLnosYyxkLGUpCmlmKHA9PT02KXtzPWQuegpyZXR1cm4gSC5XZShhLGIsYyxzLGUp
+fWlmKHI9PT04KXtpZighSC5XZShhLGIueixjLGQsZSkpcmV0dXJuITEKcmV0dXJuIEguV2UoYSxILnha
+KGEsYiksYyxkLGUpfWlmKHI9PT03KXtzPUguV2UoYSxiLnosYyxkLGUpCnJldHVybiBzfWlmKHA9PT04
+KXtpZihILldlKGEsYixjLGQueixlKSlyZXR1cm4hMApyZXR1cm4gSC5XZShhLGIsYyxILnhaKGEsZCks
+ZSl9aWYocD09PTcpe3M9SC5XZShhLGIsYyxkLnosZSkKcmV0dXJuIHN9aWYocSlyZXR1cm4hMQpzPXIh
+PT0xMQppZigoIXN8fHI9PT0xMikmJmQ9PT10LlkpcmV0dXJuITAKaWYocD09PTEyKXtpZihiPT09dC54
+KXJldHVybiEwCmlmKHIhPT0xMilyZXR1cm4hMQpvPWIuUQpuPWQuUQptPW8ubGVuZ3RoCmlmKG0hPT1u
+Lmxlbmd0aClyZXR1cm4hMQpjPWM9PW51bGw/bzpvLmNvbmNhdChjKQplPWU9PW51bGw/bjpuLmNvbmNh
+dChlKQpmb3IobD0wO2w8bTsrK2wpe2s9b1tsXQpqPW5bbF0KaWYoIUguV2UoYSxrLGMsaixlKXx8IUgu
+V2UoYSxqLGUsayxjKSlyZXR1cm4hMX1yZXR1cm4gSC5iTyhhLGIueixjLGQueixlKX1pZihwPT09MTEp
+e2lmKGI9PT10LngpcmV0dXJuITAKaWYocylyZXR1cm4hMQpyZXR1cm4gSC5iTyhhLGIsYyxkLGUpfWlm
+KHI9PT05KXtpZihwIT09OSlyZXR1cm4hMQpyZXR1cm4gSC5wRyhhLGIsYyxkLGUpfXJldHVybiExfSwK
+Yk86ZnVuY3Rpb24oYTIsYTMsYTQsYTUsYTYpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYs
+ZSxkLGMsYixhLGEwLGExCmlmKCFILldlKGEyLGEzLnosYTQsYTUueixhNikpcmV0dXJuITEKcz1hMy5R
+CnI9YTUuUQpxPXMuYQpwPXIuYQpvPXEubGVuZ3RoCm49cC5sZW5ndGgKaWYobz5uKXJldHVybiExCm09
+bi1vCmw9cy5iCms9ci5iCmo9bC5sZW5ndGgKaT1rLmxlbmd0aAppZihvK2o8bitpKXJldHVybiExCmZv
+cihoPTA7aDxvOysraCl7Zz1xW2hdCmlmKCFILldlKGEyLHBbaF0sYTYsZyxhNCkpcmV0dXJuITF9Zm9y
+KGg9MDtoPG07KytoKXtnPWxbaF0KaWYoIUguV2UoYTIscFtvK2hdLGE2LGcsYTQpKXJldHVybiExfWZv
+cihoPTA7aDxpOysraCl7Zz1sW20raF0KaWYoIUguV2UoYTIsa1toXSxhNixnLGE0KSlyZXR1cm4hMX1m
+PXMuYwplPXIuYwpkPWYubGVuZ3RoCmM9ZS5sZW5ndGgKZm9yKGI9MCxhPTA7YTxjO2ErPTMpe2EwPWVb
+YV0KZm9yKDshMDspe2lmKGI+PWQpcmV0dXJuITEKYTE9ZltiXQpiKz0zCmlmKGEwPGExKXJldHVybiEx
+CmlmKGExPGEwKWNvbnRpbnVlCmc9ZltiLTFdCmlmKCFILldlKGEyLGVbYSsyXSxhNixnLGE0KSlyZXR1
+cm4hMQpicmVha319cmV0dXJuITB9LApwRzpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8s
+bixtLGwsaz1iLnosaj1kLnoKaWYoaz09PWope3M9Yi5RCnI9ZC5RCnE9cy5sZW5ndGgKZm9yKHA9MDtw
+PHE7KytwKXtvPXNbcF0Kbj1yW3BdCmlmKCFILldlKGEsbyxjLG4sZSkpcmV0dXJuITF9cmV0dXJuITB9
+aWYoZD09PXQuSylyZXR1cm4hMAptPUguUW8oYSxrKQppZihtPT1udWxsKXJldHVybiExCmw9bVtqXQpp
+ZihsPT1udWxsKXJldHVybiExCnE9bC5sZW5ndGgKcj1kLlEKZm9yKHA9MDtwPHE7KytwKWlmKCFILldl
+KGEsSC5jRShhLGIsbFtwXSksYyxyW3BdLGUpKXJldHVybiExCnJldHVybiEwfSwKbFI6ZnVuY3Rpb24o
+YSl7dmFyIHMscj1hLnkKaWYoIShhPT09dC5QfHxhPT09dC5UKSlpZighSC5BOChhKSlpZihyIT09Nylp
+ZighKHI9PT02JiZILmxSKGEueikpKXM9cj09PTgmJkgubFIoYS56KQplbHNlIHM9ITAKZWxzZSBzPSEw
+CmVsc2Ugcz0hMAplbHNlIHM9ITAKcmV0dXJuIHN9LApjYzpmdW5jdGlvbihhKXt2YXIgcwppZighSC5B
+OChhKSlpZighKGE9PT10Ll8pKXM9YT09PXQuSwplbHNlIHM9ITAKZWxzZSBzPSEwCnJldHVybiBzfSwK
+QTg6ZnVuY3Rpb24oYSl7dmFyIHM9YS55CnJldHVybiBzPT09Mnx8cz09PTN8fHM9PT00fHxzPT09NXx8
+YT09PXQuV30sCkl4OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPU9iamVjdC5rZXlzKGIpLHA9cS5sZW5n
+dGgKZm9yKHM9MDtzPHA7KytzKXtyPXFbc10KYVtyXT1iW3JdfX0sCkpjOmZ1bmN0aW9uIEpjKGEsYil7
+dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLng9Xy5yPV8uYz1udWxsCl8ueT0wCl8uY3k9Xy5jeD1fLmNo
+PV8uUT1fLno9bnVsbH0sCkc6ZnVuY3Rpb24gRygpe3RoaXMuYz10aGlzLmI9dGhpcy5hPW51bGx9LAps
+WTpmdW5jdGlvbiBsWShhKXt0aGlzLmE9YX0sCmtTOmZ1bmN0aW9uIGtTKCl7fSwKaU06ZnVuY3Rpb24g
+aU0oYSl7dGhpcy5hPWF9LApSOTpmdW5jdGlvbihhKXtyZXR1cm4gdC53LmIoYSl8fHQuQi5iKGEpfHx0
+LmR6LmIoYSl8fHQuSS5iKGEpfHx0LkEuYihhKXx8dC5nNC5iKGEpfHx0LmcyLmIoYSl9LApGUDpmdW5j
+dGlvbihhKXtyZXR1cm4gSC52KEguaihhKSl9fSxKPXsKUXU6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJu
+e2k6YSxwOmIsZTpjLHg6ZH19LAprczpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG49YVt2LmRpc3Bh
+dGNoUHJvcGVydHlOYW1lXQppZihuPT1udWxsKWlmKCQuQnY9PW51bGwpe0guWEQoKQpuPWFbdi5kaXNw
+YXRjaFByb3BlcnR5TmFtZV19aWYobiE9bnVsbCl7cz1uLnAKaWYoITE9PT1zKXJldHVybiBuLmkKaWYo
+ITA9PT1zKXJldHVybiBhCnI9T2JqZWN0LmdldFByb3RvdHlwZU9mKGEpCmlmKHM9PT1yKXJldHVybiBu
+LmkKaWYobi5lPT09cil0aHJvdyBILmIoUC5TWSgiUmV0dXJuIGludGVyY2VwdG9yIGZvciAiK0guRWoo
+cyhhLG4pKSkpfXE9YS5jb25zdHJ1Y3RvcgppZihxPT1udWxsKXA9bnVsbAplbHNle289JC56bQppZihv
+PT1udWxsKW89JC56bT12LmdldElzb2xhdGVUYWcoIl8kZGFydF9qcyIpCnA9cVtvXX1pZihwIT1udWxs
+KXJldHVybiBwCnA9SC53MyhhKQppZihwIT1udWxsKXJldHVybiBwCmlmKHR5cGVvZiBhPT0iZnVuY3Rp
+b24iKXJldHVybiBDLkRHCnM9T2JqZWN0LmdldFByb3RvdHlwZU9mKGEpCmlmKHM9PW51bGwpcmV0dXJu
+IEMuWlEKaWYocz09PU9iamVjdC5wcm90b3R5cGUpcmV0dXJuIEMuWlEKaWYodHlwZW9mIHE9PSJmdW5j
+dGlvbiIpe289JC56bQppZihvPT1udWxsKW89JC56bT12LmdldElzb2xhdGVUYWcoIl8kZGFydF9qcyIp
+Ck9iamVjdC5kZWZpbmVQcm9wZXJ0eShxLG8se3ZhbHVlOkMudkIsZW51bWVyYWJsZTpmYWxzZSx3cml0
+YWJsZTp0cnVlLGNvbmZpZ3VyYWJsZTp0cnVlfSkKcmV0dXJuIEMudkJ9cmV0dXJuIEMudkJ9LApRaTpm
+dW5jdGlvbihhLGIpe2lmKGE8MHx8YT40Mjk0OTY3Mjk1KXRocm93IEguYihQLlRFKGEsMCw0Mjk0OTY3
+Mjk1LCJsZW5ndGgiLG51bGwpKQpyZXR1cm4gSi5weShuZXcgQXJyYXkoYSksYil9LApLaDpmdW5jdGlv
+bihhLGIpe2lmKGE8MCl0aHJvdyBILmIoUC54WSgiTGVuZ3RoIG11c3QgYmUgYSBub24tbmVnYXRpdmUg
+aW50ZWdlcjogIithKSkKcmV0dXJuIEguUUkobmV3IEFycmF5KGEpLGIuQygiamQ8MD4iKSl9LApweTpm
+dW5jdGlvbihhLGIpe3JldHVybiBKLkVwKEguUUkoYSxiLkMoImpkPDA+IikpLGIpfSwKRXA6ZnVuY3Rp
+b24oYSxiKXthLmZpeGVkJGxlbmd0aD1BcnJheQpyZXR1cm4gYX0sCnpDOmZ1bmN0aW9uKGEpe2EuZml4
+ZWQkbGVuZ3RoPUFycmF5CmEuaW1tdXRhYmxlJGxpc3Q9QXJyYXkKcmV0dXJuIGF9LApHYTpmdW5jdGlv
+bihhKXtpZihhPDI1Nilzd2l0Y2goYSl7Y2FzZSA5OmNhc2UgMTA6Y2FzZSAxMTpjYXNlIDEyOmNhc2Ug
+MTM6Y2FzZSAzMjpjYXNlIDEzMzpjYXNlIDE2MDpyZXR1cm4hMApkZWZhdWx0OnJldHVybiExfXN3aXRj
+aChhKXtjYXNlIDU3NjA6Y2FzZSA4MTkyOmNhc2UgODE5MzpjYXNlIDgxOTQ6Y2FzZSA4MTk1OmNhc2Ug
+ODE5NjpjYXNlIDgxOTc6Y2FzZSA4MTk4OmNhc2UgODE5OTpjYXNlIDgyMDA6Y2FzZSA4MjAxOmNhc2Ug
+ODIwMjpjYXNlIDgyMzI6Y2FzZSA4MjMzOmNhc2UgODIzOTpjYXNlIDgyODc6Y2FzZSAxMjI4ODpjYXNl
+IDY1Mjc5OnJldHVybiEwCmRlZmF1bHQ6cmV0dXJuITF9fSwKbW06ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
+CmZvcihzPWEubGVuZ3RoO2I8czspe3I9Qy54Qi5XKGEsYikKaWYociE9PTMyJiZyIT09MTMmJiFKLkdh
+KHIpKWJyZWFrOysrYn1yZXR1cm4gYn0sCmMxOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpmb3IoO2I+MDti
+PXMpe3M9Yi0xCnI9Qy54Qi5PKGEscykKaWYociE9PTMyJiZyIT09MTMmJiFKLkdhKHIpKWJyZWFrfXJl
+dHVybiBifSwKUWM6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJudW1iZXIiKXJldHVybiBKLnFJLnBy
+b3RvdHlwZQppZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIEouRHIucHJvdG90eXBlCmlmKGE9PW51
+bGwpcmV0dXJuIGEKaWYoIShhIGluc3RhbmNlb2YgUC5NaCkpcmV0dXJuIEoua2QucHJvdG90eXBlCnJl
+dHVybiBhfSwKVTY6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBKLkRyLnBy
+b3RvdHlwZQppZihhPT1udWxsKXJldHVybiBhCmlmKGEuY29uc3RydWN0b3I9PUFycmF5KXJldHVybiBK
+LmpkLnByb3RvdHlwZQppZih0eXBlb2YgYSE9Im9iamVjdCIpe2lmKHR5cGVvZiBhPT0iZnVuY3Rpb24i
+KXJldHVybiBKLmM1LnByb3RvdHlwZQpyZXR1cm4gYX1pZihhIGluc3RhbmNlb2YgUC5NaClyZXR1cm4g
+YQpyZXR1cm4gSi5rcyhhKX0sCllFOmZ1bmN0aW9uKGEpe2lmKGE9PW51bGwpcmV0dXJuIGEKaWYodHlw
 ZW9mIGEhPSJvYmplY3QiKXtpZih0eXBlb2YgYT09ImZ1bmN0aW9uIilyZXR1cm4gSi5jNS5wcm90b3R5
-cGUKcmV0dXJuIGF9aWYoYSBpbnN0YW5jZW9mIFAuTWgpcmV0dXJuIGEKcmV0dXJuIEoua3MoYSl9LApZ
-RTpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJldHVybiBhCmlmKHR5cGVvZiBhIT0ib2JqZWN0Iil7aWYo
-dHlwZW9mIGE9PSJmdW5jdGlvbiIpcmV0dXJuIEouYzUucHJvdG90eXBlCnJldHVybiBhfWlmKGEgaW5z
-dGFuY2VvZiBQLk1oKXJldHVybiBhCnJldHVybiBKLmtzKGEpfSwKaWE6ZnVuY3Rpb24oYSl7aWYodHlw
-ZW9mIGE9PSJudW1iZXIiKXtpZihNYXRoLmZsb29yKGEpPT1hKXJldHVybiBKLmJVLnByb3RvdHlwZQpy
-ZXR1cm4gSi5rRC5wcm90b3R5cGV9aWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBKLkRyLnByb3Rv
-dHlwZQppZihhPT1udWxsKXJldHVybiBKLndlLnByb3RvdHlwZQppZih0eXBlb2YgYT09ImJvb2xlYW4i
-KXJldHVybiBKLnlFLnByb3RvdHlwZQppZihhLmNvbnN0cnVjdG9yPT1BcnJheSlyZXR1cm4gSi5qZC5w
-cm90b3R5cGUKaWYodHlwZW9mIGEhPSJvYmplY3QiKXtpZih0eXBlb2YgYT09ImZ1bmN0aW9uIilyZXR1
-cm4gSi5jNS5wcm90b3R5cGUKcmV0dXJuIGF9aWYoYSBpbnN0YW5jZW9mIFAuTWgpcmV0dXJuIGEKcmV0
-dXJuIEoua3MoYSl9LApyWTpmdW5jdGlvbihhKXtpZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIEou
-RHIucHJvdG90eXBlCmlmKGE9PW51bGwpcmV0dXJuIGEKaWYoIShhIGluc3RhbmNlb2YgUC5NaCkpcmV0
-dXJuIEoua2QucHJvdG90eXBlCnJldHVybiBhfSwKdmQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJu
-dW1iZXIiKXJldHVybiBKLnFJLnByb3RvdHlwZQppZihhPT1udWxsKXJldHVybiBhCmlmKCEoYSBpbnN0
-YW5jZW9mIFAuTWgpKXJldHVybiBKLmtkLnByb3RvdHlwZQpyZXR1cm4gYX0sCncxOmZ1bmN0aW9uKGEp
-e2lmKGE9PW51bGwpcmV0dXJuIGEKaWYoYS5jb25zdHJ1Y3Rvcj09QXJyYXkpcmV0dXJuIEouamQucHJv
-dG90eXBlCmlmKHR5cGVvZiBhIT0ib2JqZWN0Iil7aWYodHlwZW9mIGE9PSJmdW5jdGlvbiIpcmV0dXJu
-IEouYzUucHJvdG90eXBlCnJldHVybiBhfWlmKGEgaW5zdGFuY2VvZiBQLk1oKXJldHVybiBhCnJldHVy
-biBKLmtzKGEpfSwKQTU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi53MShhKS5lUihhLGIpfSwKRDE6ZnVu
-Y3Rpb24oYSxiKXtyZXR1cm4gSi5yWShhKS5PWShhLGIpfSwKRWg6ZnVuY3Rpb24oYSxiLGMpe3JldHVy
-biBKLllFKGEpLm1LKGEsYixjKX0sCkVsOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEoudzEoYSkuZHIoYSxi
-KX0sCkY3OmZ1bmN0aW9uKGEpe3JldHVybiBKLlU2KGEpLmdvcihhKX0sCkZMOmZ1bmN0aW9uKGEsYil7
-cmV0dXJuIEouclkoYSkuZGQoYSxiKX0sCkdBOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEoudzEoYSkuRShh
-LGIpfSwKSG06ZnVuY3Rpb24oYSl7cmV0dXJuIEouVTYoYSkuZ0EoYSl9LApJVDpmdW5jdGlvbihhKXty
-ZXR1cm4gSi53MShhKS5nbShhKX0sCkp5OmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouaWEoYSkuZTcoYSxi
-KX0sCktWOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouclkoYSkueW4oYSxiKX0sCkx0OmZ1bmN0aW9uKGEp
-e3JldHVybiBKLllFKGEpLndnKGEpfSwKTTE6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBKLncxKGEpLkUy
-KGEsYixjKX0sCk11OmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouWUUoYSkuc1AoYSxiKX0sClF6OmZ1bmN0
-aW9uKGEsYil7cmV0dXJuIEouclkoYSkuVyhhLGIpfSwKUk06ZnVuY3Rpb24oYSxiKXtpZihhPT1udWxs
-KXJldHVybiBiPT1udWxsCmlmKHR5cGVvZiBhIT0ib2JqZWN0IilyZXR1cm4gYiE9bnVsbCYmYT09PWIK
-cmV0dXJuIEouaWEoYSkuRE4oYSxiKX0sClJYOmZ1bmN0aW9uKGEpe3JldHVybiBKLncxKGEpLmJyKGEp
-fSwKVDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEouclkoYSkuYlMoYSl9LApWdTpmdW5jdGlvbihhKXtyZXR1
-cm4gSi52ZChhKS56UShhKX0sCmE2OmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouclkoYSkuTyhhLGIpfSwK
-YXU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5yWShhKS5uQyhhLGIpfSwKYlQ6ZnVuY3Rpb24oYSl7cmV0
-dXJuIEouWUUoYSkuRDQoYSl9LApiYjpmdW5jdGlvbihhLGIpe2lmKHR5cGVvZiBhPT0ibnVtYmVyIiYm
-dHlwZW9mIGI9PSJudW1iZXIiKXJldHVybiBhK2IKcmV0dXJuIEouVEooYSkuaChhLGIpfSwKY0g6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIEouclkoYSkuaGMoYSl9LApkUjpmdW5jdGlvbihhKXtyZXR1cm4gSi5ZRShh
-KS5nUChhKX0sCmRaOmZ1bmN0aW9uKGEsYixjLGQpe3JldHVybiBKLllFKGEpLk9uKGEsYixjLGQpfSwK
-ZGc6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIEouclkoYSkuaTcoYSxiLGMsZCl9LApkaDpmdW5jdGlv
-bihhKXtyZXR1cm4gSi5ZRShhKS5GRihhKX0sCmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouWUUoYSku
-c2E0KGEsYil9LApoZjpmdW5jdGlvbihhKXtyZXR1cm4gSi5pYShhKS5naU8oYSl9LAppZzpmdW5jdGlv
-bihhKXtyZXR1cm4gSi5ZRShhKS5nUWcoYSl9LApqOmZ1bmN0aW9uKGEpe3JldHVybiBKLmlhKGEpLnco
-YSl9LApsNTpmdW5jdGlvbihhLGIpe3JldHVybiBKLllFKGEpLnNoZihhLGIpfSwKbGQ6ZnVuY3Rpb24o
-YSxiLGMpe3JldHVybiBKLnJZKGEpLk5qKGEsYixjKX0sCnA0OmZ1bmN0aW9uKGEsYil7cmV0dXJuIEou
-clkoYSkuVGMoYSxiKX0sCnEwOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gSi5yWShhKS5RaShhLGIsYyl9
-LApxRjpmdW5jdGlvbihhKXtyZXR1cm4gSi5ZRShhKS5nVmwoYSl9LAp0SDpmdW5jdGlvbihhLGIsYyl7
-cmV0dXJuIEouWUUoYSkucGsoYSxiLGMpfSwKdTk6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBKLncxKGEp
-Llk1KGEsYixjKX0sCnVVOmZ1bmN0aW9uKGEpe3JldHVybiBKLlU2KGEpLmdsMChhKX0sCndmOmZ1bmN0
-aW9uKGEsYil7cmV0dXJuIEouWUUoYSkuc1JOKGEsYil9LAp4OTpmdW5jdGlvbihhLGIpe2lmKHR5cGVv
-ZiBiPT09Im51bWJlciIpaWYoYS5jb25zdHJ1Y3Rvcj09QXJyYXl8fHR5cGVvZiBhPT0ic3RyaW5nInx8
-SC53VihhLGFbdi5kaXNwYXRjaFByb3BlcnR5TmFtZV0pKWlmKGI+Pj4wPT09YiYmYjxhLmxlbmd0aCly
-ZXR1cm4gYVtiXQpyZXR1cm4gSi5VNihhKS5xKGEsYil9LAp6bDpmdW5jdGlvbihhLGIpe3JldHVybiBK
-LlU2KGEpLnRnKGEsYil9LApHdjpmdW5jdGlvbiBHdigpe30sCnlFOmZ1bmN0aW9uIHlFKCl7fSwKd2U6
-ZnVuY3Rpb24gd2UoKXt9LApNRjpmdW5jdGlvbiBNRigpe30sCmlDOmZ1bmN0aW9uIGlDKCl7fSwKa2Q6
-ZnVuY3Rpb24ga2QoKXt9LApjNTpmdW5jdGlvbiBjNSgpe30sCmpkOmZ1bmN0aW9uIGpkKGEpe3RoaXMu
-JHRpPWF9LApQbzpmdW5jdGlvbiBQbyhhKXt0aGlzLiR0aT1hfSwKbTE6ZnVuY3Rpb24gbTEoYSxiLGMp
-e3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPTAKXy5kPW51bGwKXy4kdGk9Y30sCnFJOmZ1bmN0aW9u
-IHFJKCl7fSwKYlU6ZnVuY3Rpb24gYlUoKXt9LAprRDpmdW5jdGlvbiBrRCgpe30sCkRyOmZ1bmN0aW9u
-IERyKCl7fX0sUD17Ck9qOmZ1bmN0aW9uKCl7dmFyIHMscixxPXt9CmlmKHNlbGYuc2NoZWR1bGVJbW1l
-ZGlhdGUhPW51bGwpcmV0dXJuIFAuRVgoKQppZihzZWxmLk11dGF0aW9uT2JzZXJ2ZXIhPW51bGwmJnNl
-bGYuZG9jdW1lbnQhPW51bGwpe3M9c2VsZi5kb2N1bWVudC5jcmVhdGVFbGVtZW50KCJkaXYiKQpyPXNl
-bGYuZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpCnEuYT1udWxsCm5ldyBzZWxmLk11dGF0aW9u
-T2JzZXJ2ZXIoSC50UihuZXcgUC50aChxKSwxKSkub2JzZXJ2ZShzLHtjaGlsZExpc3Q6dHJ1ZX0pCnJl
-dHVybiBuZXcgUC5oYShxLHMscil9ZWxzZSBpZihzZWxmLnNldEltbWVkaWF0ZSE9bnVsbClyZXR1cm4g
-UC55dCgpCnJldHVybiBQLnFXKCl9LApaVjpmdW5jdGlvbihhKXtzZWxmLnNjaGVkdWxlSW1tZWRpYXRl
-KEgudFIobmV3IFAuVnModC5NLmEoYSkpLDApKX0sCm9BOmZ1bmN0aW9uKGEpe3NlbGYuc2V0SW1tZWRp
-YXRlKEgudFIobmV3IFAuRnQodC5NLmEoYSkpLDApKX0sCkJ6OmZ1bmN0aW9uKGEpe3QuTS5hKGEpClAu
-UU4oMCxhKX0sClFOOmZ1bmN0aW9uKGEsYil7dmFyIHM9bmV3IFAuVzMoKQpzLkNZKGEsYikKcmV0dXJu
-IHN9LApGWDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuaWgobmV3IFAudnMoJC5YMyxhLkMoInZzPDA+
-IikpLGEuQygiaWg8MD4iKSl9LApESTpmdW5jdGlvbihhLGIpe2EuJDIoMCxudWxsKQpiLmI9ITAKcmV0
-dXJuIGIuYX0sCmpROmZ1bmN0aW9uKGEsYil7UC5KZShhLGIpfSwKeUM6ZnVuY3Rpb24oYSxiKXtiLmFN
-KDAsYSl9LApmMzpmdW5jdGlvbihhLGIpe2IudzAoSC5SdShhKSxILnRzKGEpKX0sCkplOmZ1bmN0aW9u
-KGEsYil7dmFyIHMscixxPW5ldyBQLldNKGIpLHA9bmV3IFAuU1goYikKaWYoYSBpbnN0YW5jZW9mIFAu
-dnMpYS5RZChxLHAsdC56KQplbHNle3M9dC56CmlmKHQuZS5iKGEpKWEuU3EocSxwLHMpCmVsc2V7cj1u
-ZXcgUC52cygkLlgzLHQuYykKci5hPTQKci5jPWEKci5RZChxLHAscyl9fX0sCmx6OmZ1bmN0aW9uKGEp
-e3ZhciBzPWZ1bmN0aW9uKGIsYyl7cmV0dXJuIGZ1bmN0aW9uKGQsZSl7d2hpbGUodHJ1ZSl0cnl7Yihk
-LGUpCmJyZWFrfWNhdGNoKHIpe2U9cgpkPWN9fX0oYSwxKQpyZXR1cm4gJC5YMy5MaihuZXcgUC5Hcyhz
-KSx0LkgsdC5TLHQueil9LApJRzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuRnkoYSwxKX0sClRoOmZ1
-bmN0aW9uKCl7cmV0dXJuIEMud1F9LApZbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuRnkoYSwzKX0s
-CmwwOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBQLnE0KGEsYi5DKCJxNDwwPiIpKX0sClRsOmZ1bmN0
-aW9uKGEsYil7dmFyIHM9SC5jYihhLCJlcnJvciIsdC5LKQpyZXR1cm4gbmV3IFAuQ3cocyxiPT1udWxs
-P1AudjAoYSk6Yil9LAp2MDpmdW5jdGlvbihhKXt2YXIgcwppZih0LnIuYihhKSl7cz1hLmdJSSgpCmlm
-KHMhPW51bGwpcmV0dXJuIHN9cmV0dXJuIEMucGR9LApBOTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpm
-b3Iocz10LmM7cj1hLmEscj09PTI7KWE9cy5hKGEuYykKaWYocj49NCl7cT1iLmFoKCkKYi5hPWEuYQpi
-LmM9YS5jClAuSFooYixxKX1lbHNle3E9dC5GLmEoYi5jKQpiLmE9MgpiLmM9YQphLmpRKHEpfX0sCkha
-OmZ1bmN0aW9uKGEwLGExKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxjPW51bGws
-Yj17fSxhPWIuYT1hMApmb3Iocz10Lm4scj10LkYscT10LmU7ITA7KXtwPXt9Cm89YS5hPT09OAppZihh
-MT09bnVsbCl7aWYobyl7bj1zLmEoYS5jKQpQLkwyKGMsYyxhLmIsbi5hLG4uYil9cmV0dXJufXAuYT1h
-MQptPWExLmEKZm9yKGE9YTE7bSE9bnVsbDthPW0sbT1sKXthLmE9bnVsbApQLkhaKGIuYSxhKQpwLmE9
-bQpsPW0uYX1rPWIuYQpqPWsuYwpwLmI9bwpwLmM9agppPSFvCmlmKGkpe2g9YS5jCmg9KGgmMSkhPT0w
-fHwoaCYxNSk9PT04fWVsc2UgaD0hMAppZihoKXtnPWEuYi5iCmlmKG8pe2g9ay5iPT09ZwpoPSEoaHx8
-aCl9ZWxzZSBoPSExCmlmKGgpe3MuYShqKQpQLkwyKGMsYyxrLmIsai5hLGouYikKcmV0dXJufWY9JC5Y
-MwppZihmIT09ZykkLlgzPWcKZWxzZSBmPWMKYT1hLmMKaWYoKGEmMTUpPT09OCluZXcgUC5SVChwLGIs
-bykuJDAoKQplbHNlIGlmKGkpe2lmKChhJjEpIT09MCluZXcgUC5ycShwLGopLiQwKCl9ZWxzZSBpZigo
-YSYyKSE9PTApbmV3IFAuUlcoYixwKS4kMCgpCmlmKGYhPW51bGwpJC5YMz1mCmE9cC5jCmlmKHEuYihh
-KSl7az1wLmEuJHRpCms9ay5DKCJiODwyPiIpLmIoYSl8fCFrLlFbMV0uYihhKX1lbHNlIGs9ITEKaWYo
-ayl7cS5hKGEpCmU9cC5hLmIKaWYoYSBpbnN0YW5jZW9mIFAudnMpaWYoYS5hPj00KXtkPXIuYShlLmMp
-CmUuYz1udWxsCmExPWUuTjgoZCkKZS5hPWEuYQplLmM9YS5jCmIuYT1hCmNvbnRpbnVlfWVsc2UgUC5B
-OShhLGUpCmVsc2UgZS5lYyhhKQpyZXR1cm59fWU9cC5hLmIKZD1yLmEoZS5jKQplLmM9bnVsbAphMT1l
-Lk44KGQpCmE9cC5iCms9cC5jCmlmKCFhKXtlLiR0aS5jLmEoaykKZS5hPTQKZS5jPWt9ZWxzZXtzLmEo
-aykKZS5hPTgKZS5jPWt9Yi5hPWUKYT1lfX0sClZIOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYodC5hZy5i
-KGEpKXJldHVybiBiLkxqKGEsdC56LHQuSyx0LmwpCnM9dC5iSQppZihzLmIoYSkpcmV0dXJuIHMuYShh
-KQp0aHJvdyBILmIoUC5MMyhhLCJvbkVycm9yIiwiRXJyb3IgaGFuZGxlciBtdXN0IGFjY2VwdCBvbmUg
-T2JqZWN0IG9yIG9uZSBPYmplY3QgYW5kIGEgU3RhY2tUcmFjZSBhcyBhcmd1bWVudHMsIGFuZCByZXR1
-cm4gYSB2YWxpZCByZXN1bHQiKSl9LApwdTpmdW5jdGlvbigpe3ZhciBzLHIKZm9yKHM9JC5TNjtzIT1u
-dWxsO3M9JC5TNil7JC5tZz1udWxsCnI9cy5iCiQuUzY9cgppZihyPT1udWxsKSQuazg9bnVsbApzLmEu
-JDAoKX19LAplTjpmdW5jdGlvbigpeyQuVUQ9ITAKdHJ5e1AucHUoKX1maW5hbGx5eyQubWc9bnVsbAok
-LlVEPSExCmlmKCQuUzYhPW51bGwpJC51dCgpLiQxKFAuVUkoKSl9fSwKZVc6ZnVuY3Rpb24oYSl7dmFy
-IHM9bmV3IFAuT00oYSkscj0kLms4CmlmKHI9PW51bGwpeyQuUzY9JC5rOD1zCmlmKCEkLlVEKSQudXQo
-KS4kMShQLlVJKCkpfWVsc2UgJC5rOD1yLmI9c30sCnJSOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPSQu
-UzYKaWYocD09bnVsbCl7UC5lVyhhKQokLm1nPSQuazgKcmV0dXJufXM9bmV3IFAuT00oYSkKcj0kLm1n
-CmlmKHI9PW51bGwpe3MuYj1wCiQuUzY9JC5tZz1zfWVsc2V7cT1yLmIKcy5iPXEKJC5tZz1yLmI9cwpp
-ZihxPT1udWxsKSQuazg9c319LApyYjpmdW5jdGlvbihhKXt2YXIgcz1udWxsLHI9JC5YMwppZihDLk5V
-PT09cil7UC5UayhzLHMsQy5OVSxhKQpyZXR1cm59UC5UayhzLHMscix0Lk0uYShyLkdZKGEpKSl9LApR
-dzpmdW5jdGlvbihhLGIpe0guY2IoYSwic3RyZWFtIix0LkspCnJldHVybiBuZXcgUC54SShiLkMoInhJ
-PDA+IikpfSwKTDI6ZnVuY3Rpb24oYSxiLGMsZCxlKXtQLnJSKG5ldyBQLnBLKGQsZSkpfSwKVDg6ZnVu
-Y3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDAoKQokLlgzPWMK
-cz1yCnRyeXtyPWQuJDAoKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LAp5djpmdW5jdGlvbihhLGIs
-YyxkLGUsZixnKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDEoZSkKJC5YMz1jCnM9cgp0
-cnl7cj1kLiQxKGUpCnJldHVybiByfWZpbmFsbHl7JC5YMz1zfX0sClF4OmZ1bmN0aW9uKGEsYixjLGQs
-ZSxmLGcsaCxpKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDIoZSxmKQokLlgzPWMKcz1y
-CnRyeXtyPWQuJDIoZSxmKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LApUazpmdW5jdGlvbihhLGIs
-YyxkKXt0Lk0uYShkKQppZihDLk5VIT09YylkPWMuR1koZCkKUC5lVyhkKX0sCnRoOmZ1bmN0aW9uIHRo
-KGEpe3RoaXMuYT1hfSwKaGE6ZnVuY3Rpb24gaGEoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMu
-Yz1jfSwKVnM6ZnVuY3Rpb24gVnMoYSl7dGhpcy5hPWF9LApGdDpmdW5jdGlvbiBGdChhKXt0aGlzLmE9
-YX0sClczOmZ1bmN0aW9uIFczKCl7fSwKeUg6ZnVuY3Rpb24geUgoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
-Yn0sCmloOmZ1bmN0aW9uIGloKGEsYil7dGhpcy5hPWEKdGhpcy5iPSExCnRoaXMuJHRpPWJ9LApXTTpm
-dW5jdGlvbiBXTShhKXt0aGlzLmE9YX0sClNYOmZ1bmN0aW9uIFNYKGEpe3RoaXMuYT1hfSwKR3M6ZnVu
-Y3Rpb24gR3MoYSl7dGhpcy5hPWF9LApGeTpmdW5jdGlvbiBGeShhLGIpe3RoaXMuYT1hCnRoaXMuYj1i
-fSwKR1Y6ZnVuY3Rpb24gR1YoYSxiKXt2YXIgXz10aGlzCl8uYT1hCl8uZD1fLmM9Xy5iPW51bGwKXy4k
-dGk9Yn0sCnE0OmZ1bmN0aW9uIHE0KGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCkN3OmZ1bmN0aW9u
-IEN3KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApQZjpmdW5jdGlvbiBQZigpe30sClpmOmZ1bmN0aW9u
-IFpmKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCkZlOmZ1bmN0aW9uIEZlKGEsYixjLGQsZSl7dmFy
-IF89dGhpcwpfLmE9bnVsbApfLmI9YQpfLmM9YgpfLmQ9YwpfLmU9ZApfLiR0aT1lfSwKdnM6ZnVuY3Rp
-b24gdnMoYSxiKXt2YXIgXz10aGlzCl8uYT0wCl8uYj1hCl8uYz1udWxsCl8uJHRpPWJ9LApkYTpmdW5j
-dGlvbiBkYShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKb1E6ZnVuY3Rpb24gb1EoYSxiKXt0aGlzLmE9
-YQp0aGlzLmI9Yn0sCnBWOmZ1bmN0aW9uIHBWKGEpe3RoaXMuYT1hfSwKVTc6ZnVuY3Rpb24gVTcoYSl7
-dGhpcy5hPWF9LAp2cjpmdW5jdGlvbiB2cihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9
-LApydDpmdW5jdGlvbiBydChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKS0Y6ZnVuY3Rpb24gS0YoYSxi
-KXt0aGlzLmE9YQp0aGlzLmI9Yn0sClpMOmZ1bmN0aW9uIFpMKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9
-Ygp0aGlzLmM9Y30sClJUOmZ1bmN0aW9uIFJUKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9
-Y30sCmpaOmZ1bmN0aW9uIGpaKGEpe3RoaXMuYT1hfSwKcnE6ZnVuY3Rpb24gcnEoYSxiKXt0aGlzLmE9
-YQp0aGlzLmI9Yn0sClJXOmZ1bmN0aW9uIFJXKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApPTTpmdW5j
-dGlvbiBPTShhKXt0aGlzLmE9YQp0aGlzLmI9bnVsbH0sCnFoOmZ1bmN0aW9uIHFoKCl7fSwKQjU6ZnVu
-Y3Rpb24gQjUoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCnVPOmZ1bmN0aW9uIHVPKGEsYil7dGhpcy5h
-PWEKdGhpcy5iPWJ9LApNTzpmdW5jdGlvbiBNTygpe30sCmtUOmZ1bmN0aW9uIGtUKCl7fSwKeEk6ZnVu
-Y3Rpb24geEkoYSl7dGhpcy4kdGk9YX0sCm0wOmZ1bmN0aW9uIG0wKCl7fSwKcEs6ZnVuY3Rpb24gcEso
-YSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkppOmZ1bmN0aW9uIEppKCl7fSwKVnA6ZnVuY3Rpb24gVnAo
-YSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCk9SOmZ1bmN0aW9uIE9SKGEsYixjKXt0aGlzLmE9YQp0aGlz
-LmI9Ygp0aGlzLmM9Y30sCkVGOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gYi5DKCJAPDA+IikuS3EoYyku
-QygiRm88MSwyPiIpLmEoSC5CNyhhLG5ldyBILk41KGIuQygiQDwwPiIpLktxKGMpLkMoIk41PDEsMj4i
-KSkpKX0sCkZsOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILk41KGEuQygiQDwwPiIpLktxKGIpLkMo
-Ik41PDEsMj4iKSl9LApMczpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuYjYoYS5DKCJiNjwwPiIpKX0s
-ClQyOmZ1bmN0aW9uKCl7dmFyIHM9T2JqZWN0LmNyZWF0ZShudWxsKQpzWyI8bm9uLWlkZW50aWZpZXIt
-a2V5PiJdPXMKZGVsZXRlIHNbIjxub24taWRlbnRpZmllci1rZXk+Il0KcmV0dXJuIHN9LApyajpmdW5j
-dGlvbihhLGIsYyl7dmFyIHM9bmV3IFAubG0oYSxiLGMuQygibG08MD4iKSkKcy5jPWEuZQpyZXR1cm4g
-c30sCkVQOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCmlmKFAuaEIoYSkpe2lmKGI9PT0iKCImJmM9PT0i
-KSIpcmV0dXJuIiguLi4pIgpyZXR1cm4gYisiLi4uIitjfXM9SC5WTShbXSx0LnMpCkMuTm0uaSgkLnhn
-LGEpCnRyeXtQLlZyKGEscyl9ZmluYWxseXtpZigwPj0kLnhnLmxlbmd0aClyZXR1cm4gSC5PSCgkLnhn
-LC0xKQokLnhnLnBvcCgpfXI9UC52ZyhiLHQudS5hKHMpLCIsICIpK2MKcmV0dXJuIHIuY2hhckNvZGVB
-dCgwKT09MD9yOnJ9LApXRTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscgppZihQLmhCKGEpKXJldHVybiBi
-KyIuLi4iK2MKcz1uZXcgUC5SbihiKQpDLk5tLmkoJC54ZyxhKQp0cnl7cj1zCnIuYT1QLnZnKHIuYSxh
-LCIsICIpfWZpbmFsbHl7aWYoMD49JC54Zy5sZW5ndGgpcmV0dXJuIEguT0goJC54ZywtMSkKJC54Zy5w
-b3AoKX1zLmErPWMKcj1zLmEKcmV0dXJuIHIuY2hhckNvZGVBdCgwKT09MD9yOnJ9LApoQjpmdW5jdGlv
-bihhKXt2YXIgcyxyCmZvcihzPSQueGcubGVuZ3RoLHI9MDtyPHM7KytyKWlmKGE9PT0kLnhnW3JdKXJl
-dHVybiEwCnJldHVybiExfSwKVnI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsPWEuZ20o
-YSksaz0wLGo9MAp3aGlsZSghMCl7aWYoIShrPDgwfHxqPDMpKWJyZWFrCmlmKCFsLkYoKSlyZXR1cm4K
-cz1ILkVqKGwuZ2woKSkKQy5ObS5pKGIscykKays9cy5sZW5ndGgrMjsrK2p9aWYoIWwuRigpKXtpZihq
-PD01KXJldHVybgppZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChiLC0xKQpyPWIucG9wKCkKaWYoMD49
-Yi5sZW5ndGgpcmV0dXJuIEguT0goYiwtMSkKcT1iLnBvcCgpfWVsc2V7cD1sLmdsKCk7KytqCmlmKCFs
-LkYoKSl7aWYoajw9NCl7Qy5ObS5pKGIsSC5FaihwKSkKcmV0dXJufXI9SC5FaihwKQppZigwPj1iLmxl
-bmd0aClyZXR1cm4gSC5PSChiLC0xKQpxPWIucG9wKCkKays9ci5sZW5ndGgrMn1lbHNle289bC5nbCgp
-Oysragpmb3IoO2wuRigpO3A9byxvPW4pe249bC5nbCgpOysragppZihqPjEwMCl7d2hpbGUoITApe2lm
-KCEoaz43NSYmaj4zKSlicmVhawppZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChiLC0xKQprLT1iLnBv
-cCgpLmxlbmd0aCsyOy0tan1DLk5tLmkoYiwiLi4uIikKcmV0dXJufX1xPUguRWoocCkKcj1ILkVqKG8p
-CmsrPXIubGVuZ3RoK3EubGVuZ3RoKzR9fWlmKGo+Yi5sZW5ndGgrMil7ays9NQptPSIuLi4ifWVsc2Ug
-bT1udWxsCndoaWxlKCEwKXtpZighKGs+ODAmJmIubGVuZ3RoPjMpKWJyZWFrCmlmKDA+PWIubGVuZ3Ro
-KXJldHVybiBILk9IKGIsLTEpCmstPWIucG9wKCkubGVuZ3RoKzIKaWYobT09bnVsbCl7ays9NQptPSIu
-Li4ifX1pZihtIT1udWxsKUMuTm0uaShiLG0pCkMuTm0uaShiLHEpCkMuTm0uaShiLHIpfSwKdE06ZnVu
-Y3Rpb24oYSxiKXt2YXIgcyxyLHE9UC5McyhiKQpmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDth
-Lmxlbmd0aD09PXN8fCgwLEgubGspKGEpLCsrcilxLmkoMCxiLmEoYVtyXSkpCnJldHVybiBxfSwKbk86
-ZnVuY3Rpb24oYSl7dmFyIHMscj17fQppZihQLmhCKGEpKXJldHVybiJ7Li4ufSIKcz1uZXcgUC5Sbigi
-IikKdHJ5e0MuTm0uaSgkLnhnLGEpCnMuYSs9InsiCnIuYT0hMAphLksoMCxuZXcgUC5yYShyLHMpKQpz
-LmErPSJ9In1maW5hbGx5e2lmKDA+PSQueGcubGVuZ3RoKXJldHVybiBILk9IKCQueGcsLTEpCiQueGcu
-cG9wKCl9cj1zLmEKcmV0dXJuIHIuY2hhckNvZGVBdCgwKT09MD9yOnJ9LApiNjpmdW5jdGlvbiBiNihh
-KXt2YXIgXz10aGlzCl8uYT0wCl8uZj1fLmU9Xy5kPV8uYz1fLmI9bnVsbApfLnI9MApfLiR0aT1hfSwK
-Ym46ZnVuY3Rpb24gYm4oYSl7dGhpcy5hPWEKdGhpcy5jPXRoaXMuYj1udWxsfSwKbG06ZnVuY3Rpb24g
-bG0oYSxiLGMpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5kPV8uYz1udWxsCl8uJHRpPWN9LAptVzpm
-dW5jdGlvbiBtVygpe30sCnV5OmZ1bmN0aW9uIHV5KCl7fSwKbEQ6ZnVuY3Rpb24gbEQoKXt9LAppbDpm
-dW5jdGlvbiBpbCgpe30sCnJhOmZ1bmN0aW9uIHJhKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApZazpm
-dW5jdGlvbiBZaygpe30sCnlROmZ1bmN0aW9uIHlRKGEpe3RoaXMuYT1hfSwKS1A6ZnVuY3Rpb24gS1Ao
-KXt9LApQbjpmdW5jdGlvbiBQbigpe30sCkdqOmZ1bmN0aW9uIEdqKGEsYil7dGhpcy5hPWEKdGhpcy4k
-dGk9Yn0sCmxmOmZ1bmN0aW9uIGxmKCl7fSwKVmo6ZnVuY3Rpb24gVmooKXt9LApYdjpmdW5jdGlvbiBY
-digpe30sCm5ZOmZ1bmN0aW9uIG5ZKCl7fSwKV1k6ZnVuY3Rpb24gV1koKXt9LApSVTpmdW5jdGlvbiBS
-VSgpe30sCnBSOmZ1bmN0aW9uIHBSKCl7fSwKQlM6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscAppZih0
-eXBlb2YgYSE9InN0cmluZyIpdGhyb3cgSC5iKEgudEwoYSkpCnM9bnVsbAp0cnl7cz1KU09OLnBhcnNl
-KGEpfWNhdGNoKHEpe3I9SC5SdShxKQpwPVAucnIoU3RyaW5nKHIpLG51bGwsbnVsbCkKdGhyb3cgSC5i
-KHApfXA9UC5RZShzKQpyZXR1cm4gcH0sClFlOmZ1bmN0aW9uKGEpe3ZhciBzCmlmKGE9PW51bGwpcmV0
-dXJuIG51bGwKaWYodHlwZW9mIGEhPSJvYmplY3QiKXJldHVybiBhCmlmKE9iamVjdC5nZXRQcm90b3R5
-cGVPZihhKSE9PUFycmF5LnByb3RvdHlwZSlyZXR1cm4gbmV3IFAudXcoYSxPYmplY3QuY3JlYXRlKG51
-bGwpKQpmb3Iocz0wO3M8YS5sZW5ndGg7KytzKWFbc109UC5RZShhW3NdKQpyZXR1cm4gYX0sCmt5OmZ1
-bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIKaWYoYiBpbnN0YW5jZW9mIFVpbnQ4QXJyYXkpe3M9YgpkPXMu
-bGVuZ3RoCmlmKGQtYzwxNSlyZXR1cm4gbnVsbApyPVAuUlAoYSxzLGMsZCkKaWYociE9bnVsbCYmYSlp
-ZihyLmluZGV4T2YoIlx1ZmZmZCIpPj0wKXJldHVybiBudWxsCnJldHVybiByfXJldHVybiBudWxsfSwK
-UlA6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9YT8kLkhHKCk6JC5yZigpCmlmKHM9PW51bGwpcmV0dXJu
-IG51bGwKaWYoMD09PWMmJmQ9PT1iLmxlbmd0aClyZXR1cm4gUC5SYihzLGIpCnJldHVybiBQLlJiKHMs
-Yi5zdWJhcnJheShjLFAuakIoYyxkLGIubGVuZ3RoKSkpfSwKUmI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
-CnRyeXtzPWEuZGVjb2RlKGIpCnJldHVybiBzfWNhdGNoKHIpe0guUnUocil9cmV0dXJuIG51bGx9LAp4
-TTpmdW5jdGlvbihhLGIsYyxkLGUsZil7aWYoQy5qbi56WShmLDQpIT09MCl0aHJvdyBILmIoUC5ycigi
-SW52YWxpZCBiYXNlNjQgcGFkZGluZywgcGFkZGVkIGxlbmd0aCBtdXN0IGJlIG11bHRpcGxlIG9mIGZv
-dXIsIGlzICIrZixhLGMpKQppZihkK2UhPT1mKXRocm93IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBw
-YWRkaW5nLCAnPScgbm90IGF0IHRoZSBlbmQiLGEsYikpCmlmKGU+Mil0aHJvdyBILmIoUC5ycigiSW52
-YWxpZCBiYXNlNjQgcGFkZGluZywgbW9yZSB0aGFuIHR3byAnPScgY2hhcmFjdGVycyIsYSxiKSl9LApH
-eTpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIG5ldyBQLlVkKGEsYil9LApOQzpmdW5jdGlvbihhKXtyZXR1
-cm4gYS5MdCgpfSwKVWc6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IFAudHUoYSxbXSxQLkN5KCkpfSwK
-dVg6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9bmV3IFAuUm4oIiIpLHE9UC5VZyhyLGIpCnEuaVUoYSkK
-cz1yLmEKcmV0dXJuIHMuY2hhckNvZGVBdCgwKT09MD9zOnN9LApqNDpmdW5jdGlvbihhKXtzd2l0Y2go
-YSl7Y2FzZSA2NTpyZXR1cm4iTWlzc2luZyBleHRlbnNpb24gYnl0ZSIKY2FzZSA2NzpyZXR1cm4iVW5l
-eHBlY3RlZCBleHRlbnNpb24gYnl0ZSIKY2FzZSA2OTpyZXR1cm4iSW52YWxpZCBVVEYtOCBieXRlIgpj
-YXNlIDcxOnJldHVybiJPdmVybG9uZyBlbmNvZGluZyIKY2FzZSA3MzpyZXR1cm4iT3V0IG9mIHVuaWNv
-ZGUgcmFuZ2UiCmNhc2UgNzU6cmV0dXJuIkVuY29kZWQgc3Vycm9nYXRlIgpjYXNlIDc3OnJldHVybiJV
-bmZpbmlzaGVkIFVURi04IG9jdGV0IHNlcXVlbmNlIgpkZWZhdWx0OnJldHVybiIifX0sCmp5OmZ1bmN0
-aW9uKGEsYixjKXt2YXIgcyxyLHEscD1jLWIsbz1uZXcgVWludDhBcnJheShwKQpmb3Iocz1KLlU2KGEp
-LHI9MDtyPHA7KytyKXtxPXMucShhLGIrcikKaWYodHlwZW9mIHEhPT0ibnVtYmVyIilyZXR1cm4gcS56
-TSgpCmlmKChxJjQyOTQ5NjcwNDApPj4+MCE9PTApcT0yNTUKaWYocj49cClyZXR1cm4gSC5PSChvLHIp
-Cm9bcl09cX1yZXR1cm4gb30sCnV3OmZ1bmN0aW9uIHV3KGEsYil7dGhpcy5hPWEKdGhpcy5iPWIKdGhp
-cy5jPW51bGx9LAppODpmdW5jdGlvbiBpOChhKXt0aGlzLmE9YX0sCnhyOmZ1bmN0aW9uIHhyKCl7fSwK
-Tno6ZnVuY3Rpb24gTnooKXt9LApDVjpmdW5jdGlvbiBDVigpe30sClU4OmZ1bmN0aW9uIFU4KCl7fSwK
-VWs6ZnVuY3Rpb24gVWsoKXt9LAp3STpmdW5jdGlvbiB3SSgpe30sClppOmZ1bmN0aW9uIFppKCl7fSwK
-VWQ6ZnVuY3Rpb24gVWQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCks4OmZ1bmN0aW9uIEs4KGEsYil7
-dGhpcy5hPWEKdGhpcy5iPWJ9LApieTpmdW5jdGlvbiBieSgpe30sCm9qOmZ1bmN0aW9uIG9qKGEpe3Ro
-aXMuYj1hfSwKTXg6ZnVuY3Rpb24gTXgoYSl7dGhpcy5hPWF9LApTaDpmdW5jdGlvbiBTaCgpe30sCnRp
-OmZ1bmN0aW9uIHRpKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LAp0dTpmdW5jdGlvbiB0dShhLGIsYyl7
-dGhpcy5jPWEKdGhpcy5hPWIKdGhpcy5iPWN9LAp1NTpmdW5jdGlvbiB1NSgpe30sCkUzOmZ1bmN0aW9u
-IEUzKCl7fSwKUnc6ZnVuY3Rpb24gUncoYSl7dGhpcy5iPTAKdGhpcy5jPWF9LApHWTpmdW5jdGlvbiBH
-WShhKXt0aGlzLmE9YX0sCmJ6OmZ1bmN0aW9uIGJ6KGEpe3RoaXMuYT1hCnRoaXMuYj0xNgp0aGlzLmM9
-MH0sClFBOmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5IcChhLGIpCmlmKHMhPW51bGwpcmV0dXJuIHMKdGhy
-b3cgSC5iKFAucnIoYSxudWxsLG51bGwpKX0sCm9zOmZ1bmN0aW9uKGEpe2lmKGEgaW5zdGFuY2VvZiBI
-LlRwKXJldHVybiBhLncoMCkKcmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5NKGEpKSsiJyJ9LApP
-ODpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyPWM/Si5LaChhLGQpOkouUWkoYSxkKQppZihhIT09MCYm
-YiE9bnVsbClmb3Iocz0wO3M8ci5sZW5ndGg7KytzKXJbc109YgpyZXR1cm4gcn0sCkNIOmZ1bmN0aW9u
-KGEsYixjKXt2YXIgcyxyPUguVk0oW10sYy5DKCJqZDwwPiIpKQpmb3Iocz1KLklUKGEpO3MuRigpOylD
-Lk5tLmkocixjLmEocy5nbCgpKSkKaWYoYilyZXR1cm4gcgpyZXR1cm4gSi5FcChyLGMpfSwKWTE6ZnVu
-Y3Rpb24oYSxiLGMpe3ZhciBzCmlmKGIpcmV0dXJuIFAuZXYoYSxjKQpzPUouRXAoUC5ldihhLGMpLGMp
-CnJldHVybiBzfSwKZXY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKEFycmF5LmlzQXJyYXkoYSkpcmV0
-dXJuIEguVk0oYS5zbGljZSgwKSxiLkMoImpkPDA+IikpCnM9SC5WTShbXSxiLkMoImpkPDA+IikpCmZv
-cihyPUouSVQoYSk7ci5GKCk7KUMuTm0uaShzLHIuZ2woKSkKcmV0dXJuIHN9LApBRjpmdW5jdGlvbihh
-LGIpe3JldHVybiBKLnpDKFAuQ0goYSwhMSxiKSl9LApITTpmdW5jdGlvbihhLGIsYyl7aWYodC5ibS5i
-KGEpKXJldHVybiBILmZ3KGEsYixQLmpCKGIsYyxhLmxlbmd0aCkpCnJldHVybiBQLmJ3KGEsYixjKX0s
-Ck9vOmZ1bmN0aW9uKGEpe3JldHVybiBILkx3KGEpfSwKYnc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIs
-cSxwLG89bnVsbAppZihiPDApdGhyb3cgSC5iKFAuVEUoYiwwLGEubGVuZ3RoLG8sbykpCnM9Yz09bnVs
-bAppZighcyYmYzxiKXRocm93IEguYihQLlRFKGMsYixhLmxlbmd0aCxvLG8pKQpyPW5ldyBILmE3KGEs
-YS5sZW5ndGgsSC56KGEpLkMoImE3PGxELkU+IikpCmZvcihxPTA7cTxiOysrcSlpZighci5GKCkpdGhy
-b3cgSC5iKFAuVEUoYiwwLHEsbyxvKSkKcD1bXQppZihzKWZvcig7ci5GKCk7KXAucHVzaChyLmQpCmVs
-c2UgZm9yKHE9YjtxPGM7KytxKXtpZighci5GKCkpdGhyb3cgSC5iKFAuVEUoYyxiLHEsbyxvKSkKcC5w
-dXNoKHIuZCl9cmV0dXJuIEguZVQocCl9LApudTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguVlIoYSxI
-LnY0KGEsITEsITAsITEsITEsITEpKX0sCnZnOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1KLklUKGIpCmlm
-KCFzLkYoKSlyZXR1cm4gYQppZihjLmxlbmd0aD09PTApe2RvIGErPUguRWoocy5nbCgpKQp3aGlsZShz
-LkYoKSl9ZWxzZXthKz1ILkVqKHMuZ2woKSkKZm9yKDtzLkYoKTspYT1hK2MrSC5FaihzLmdsKCkpfXJl
-dHVybiBhfSwKbHI6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIG5ldyBQLm1wKGEsYixjLGQpfSwKdW86
-ZnVuY3Rpb24oKXt2YXIgcz1ILk0wKCkKaWYocyE9bnVsbClyZXR1cm4gUC5oSyhzKQp0aHJvdyBILmIo
-UC5MNCgiJ1VyaS5iYXNlJyBpcyBub3Qgc3VwcG9ydGVkIikpfSwKZVA6ZnVuY3Rpb24oYSxiLGMsZCl7
-dmFyIHMscixxLHAsbyxuLG09IjAxMjM0NTY3ODlBQkNERUYiCmlmKGM9PT1DLnhNKXtzPSQuejQoKS5i
-CmlmKHR5cGVvZiBiIT0ic3RyaW5nIilILnYoSC50TChiKSkKcz1zLnRlc3QoYil9ZWxzZSBzPSExCmlm
-KHMpcmV0dXJuIGIKSC5MaChjKS5DKCJVay5TIikuYShiKQpyPWMuZ1pFKCkuV0ooYikKZm9yKHM9ci5s
-ZW5ndGgscT0wLHA9IiI7cTxzOysrcSl7bz1yW3FdCmlmKG88MTI4KXtuPW8+Pj40CmlmKG4+PTgpcmV0
-dXJuIEguT0goYSxuKQpuPShhW25dJjE8PChvJjE1KSkhPT0wfWVsc2Ugbj0hMQppZihuKXArPUguTHco
-bykKZWxzZSBwPWQmJm89PT0zMj9wKyIrIjpwKyIlIittW28+Pj40JjE1XSttW28mMTVdfXJldHVybiBw
-LmNoYXJDb2RlQXQoMCk9PTA/cDpwfSwKR3E6ZnVuY3Rpb24oYSl7dmFyIHM9TWF0aC5hYnMoYSkscj1h
-PDA/Ii0iOiIiCmlmKHM+PTEwMDApcmV0dXJuIiIrYQppZihzPj0xMDApcmV0dXJuIHIrIjAiK3MKaWYo
-cz49MTApcmV0dXJuIHIrIjAwIitzCnJldHVybiByKyIwMDAiK3N9LApWeDpmdW5jdGlvbihhKXtpZihh
-Pj0xMDApcmV0dXJuIiIrYQppZihhPj0xMClyZXR1cm4iMCIrYQpyZXR1cm4iMDAiK2F9LApoMDpmdW5j
-dGlvbihhKXtpZihhPj0xMClyZXR1cm4iIithCnJldHVybiIwIithfSwKcDpmdW5jdGlvbihhKXtpZih0
-eXBlb2YgYT09Im51bWJlciJ8fEgubChhKXx8bnVsbD09YSlyZXR1cm4gSi5qKGEpCmlmKHR5cGVvZiBh
-PT0ic3RyaW5nIilyZXR1cm4gSlNPTi5zdHJpbmdpZnkoYSkKcmV0dXJuIFAub3MoYSl9LApoVjpmdW5j
-dGlvbihhKXtyZXR1cm4gbmV3IFAuQzYoYSl9LAp4WTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAudSgh
-MSxudWxsLG51bGwsYSl9LApMMzpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIG5ldyBQLnUoITAsYSxiLGMp
-fSwKTzc6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IFAuYkoobnVsbCxudWxsLCEwLGEsYiwiVmFsdWUg
-bm90IGluIHJhbmdlIil9LApURTpmdW5jdGlvbihhLGIsYyxkLGUpe3JldHVybiBuZXcgUC5iSihiLGMs
-ITAsYSxkLCJJbnZhbGlkIHZhbHVlIil9LAp3QTpmdW5jdGlvbihhLGIsYyxkKXtpZihhPGJ8fGE+Yyl0
-aHJvdyBILmIoUC5URShhLGIsYyxkLG51bGwpKQpyZXR1cm4gYX0sCmpCOmZ1bmN0aW9uKGEsYixjKXtp
-ZigwPmF8fGE+Yyl0aHJvdyBILmIoUC5URShhLDAsYywic3RhcnQiLG51bGwpKQppZihiIT1udWxsKXtp
-ZihhPmJ8fGI+Yyl0aHJvdyBILmIoUC5URShiLGEsYywiZW5kIixudWxsKSkKcmV0dXJuIGJ9cmV0dXJu
-IGN9LAprMTpmdW5jdGlvbihhLGIpe2lmKGE8MCl0aHJvdyBILmIoUC5URShhLDAsbnVsbCxiLG51bGwp
-KQpyZXR1cm4gYX0sCkNmOmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHM9SC51UChlPT1udWxsP0ouSG0o
-Yik6ZSkKcmV0dXJuIG5ldyBQLmVZKHMsITAsYSxjLCJJbmRleCBvdXQgb2YgcmFuZ2UiKX0sCkw0OmZ1
-bmN0aW9uKGEpe3JldHVybiBuZXcgUC51YihhKX0sClNZOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5k
-cyhhKX0sClBWOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5saihhKX0sCmE0OmZ1bmN0aW9uKGEpe3Jl
-dHVybiBuZXcgUC5VVihhKX0sCnJyOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gbmV3IFAuYUUoYSxiLGMp
-fSwKaEs6ZnVuY3Rpb24oYTUpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZSxkLGMsYixh
-LGEwLGExLGEyLGEzPW51bGwsYTQ9YTUubGVuZ3RoCmlmKGE0Pj01KXtzPSgoSi5ReihhNSw0KV41OCkq
-M3xDLnhCLlcoYTUsMCleMTAwfEMueEIuVyhhNSwxKV45N3xDLnhCLlcoYTUsMileMTE2fEMueEIuVyhh
-NSwzKV45Nyk+Pj4wCmlmKHM9PT0wKXJldHVybiBQLktEKGE0PGE0P0MueEIuTmooYTUsMCxhNCk6YTUs
-NSxhMykuZ2xSKCkKZWxzZSBpZihzPT09MzIpcmV0dXJuIFAuS0QoQy54Qi5OaihhNSw1LGE0KSwwLGEz
-KS5nbFIoKX1yPVAuTzgoOCwwLCExLHQuUykKQy5ObS5ZNShyLDAsMCkKQy5ObS5ZNShyLDEsLTEpCkMu
-Tm0uWTUociwyLC0xKQpDLk5tLlk1KHIsNywtMSkKQy5ObS5ZNShyLDMsMCkKQy5ObS5ZNShyLDQsMCkK
-Qy5ObS5ZNShyLDUsYTQpCkMuTm0uWTUociw2LGE0KQppZihQLlVCKGE1LDAsYTQsMCxyKT49MTQpQy5O
-bS5ZNShyLDcsYTQpCnE9clsxXQppZihxPj0wKWlmKFAuVUIoYTUsMCxxLDIwLHIpPT09MjApcls3XT1x
-CnA9clsyXSsxCm89clszXQpuPXJbNF0KbT1yWzVdCmw9cls2XQppZihsPG0pbT1sCmlmKG48cCluPW0K
-ZWxzZSBpZihuPD1xKW49cSsxCmlmKG88cClvPW4Kaz1yWzddPDAKaWYoaylpZihwPnErMyl7aj1hMwpr
-PSExfWVsc2V7aT1vPjAKaWYoaSYmbysxPT09bil7aj1hMwprPSExfWVsc2V7aWYoIShtPGE0JiZtPT09
-bisyJiZKLnEwKGE1LCIuLiIsbikpKWg9bT5uKzImJkoucTAoYTUsIi8uLiIsbS0zKQplbHNlIGg9ITAK
-aWYoaCl7aj1hMwprPSExfWVsc2V7aWYocT09PTQpaWYoSi5xMChhNSwiZmlsZSIsMCkpe2lmKHA8PTAp
-e2lmKCFDLnhCLlFpKGE1LCIvIixuKSl7Zz0iZmlsZTovLy8iCnM9M31lbHNle2c9ImZpbGU6Ly8iCnM9
-Mn1hNT1nK0MueEIuTmooYTUsbixhNCkKcS09MAppPXMtMAptKz1pCmwrPWkKYTQ9YTUubGVuZ3RoCnA9
-NwpvPTcKbj03fWVsc2UgaWYobj09PW0peysrbApmPW0rMQphNT1DLnhCLmk3KGE1LG4sbSwiLyIpOysr
-YTQKbT1mfWo9ImZpbGUifWVsc2UgaWYoQy54Qi5RaShhNSwiaHR0cCIsMCkpe2lmKGkmJm8rMz09PW4m
-JkMueEIuUWkoYTUsIjgwIixvKzEpKXtsLT0zCmU9bi0zCm0tPTMKYTU9Qy54Qi5pNyhhNSxvLG4sIiIp
-CmE0LT0zCm49ZX1qPSJodHRwIn1lbHNlIGo9YTMKZWxzZSBpZihxPT09NSYmSi5xMChhNSwiaHR0cHMi
-LDApKXtpZihpJiZvKzQ9PT1uJiZKLnEwKGE1LCI0NDMiLG8rMSkpe2wtPTQKZT1uLTQKbS09NAphNT1K
-LmRnKGE1LG8sbiwiIikKYTQtPTMKbj1lfWo9Imh0dHBzIn1lbHNlIGo9YTMKaz0hMH19fWVsc2Ugaj1h
-MwppZihrKXtpPWE1Lmxlbmd0aAppZihhNDxpKXthNT1KLmxkKGE1LDAsYTQpCnEtPTAKcC09MApvLT0w
-Cm4tPTAKbS09MApsLT0wfXJldHVybiBuZXcgUC5VZihhNSxxLHAsbyxuLG0sbCxqKX1pZihqPT1udWxs
-KWlmKHE+MClqPVAuUGkoYTUsMCxxKQplbHNle2lmKHE9PT0wKXtQLlIzKGE1LDAsIkludmFsaWQgZW1w
-dHkgc2NoZW1lIikKSC5CaSh1LmcpfWo9IiJ9aWYocD4wKXtkPXErMwpjPWQ8cD9QLnpSKGE1LGQscC0x
-KToiIgpiPVAuT2UoYTUscCxvLCExKQppPW8rMQppZihpPG4pe2E9SC5IcChKLmxkKGE1LGksbiksYTMp
-CmEwPVAud0IoYT09bnVsbD9ILnYoUC5ycigiSW52YWxpZCBwb3J0IixhNSxpKSk6YSxqKX1lbHNlIGEw
-PWEzfWVsc2V7YTA9YTMKYj1hMApjPSIifWExPVAua2EoYTUsbixtLGEzLGosYiE9bnVsbCkKYTI9bTxs
-P1AubGUoYTUsbSsxLGwsYTMpOmEzCnJldHVybiBQLkNnKGosYyxiLGEwLGExLGEyLGw8YTQ/UC50Ryhh
-NSxsKzEsYTQpOmEzKX0sCk10OmZ1bmN0aW9uKGEpe0guaChhKQpyZXR1cm4gUC5rdShhLDAsYS5sZW5n
-dGgsQy54TSwhMSl9LApXWDpmdW5jdGlvbihhKXt2YXIgcz10Lk4KcmV0dXJuIEMuTm0uTjAoSC5WTShh
-LnNwbGl0KCImIiksdC5zKSxQLkZsKHMscyksbmV3IFAubjEoQy54TSksdC5KKX0sCkhoOmZ1bmN0aW9u
-KGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbT0iSVB2NCBhZGRyZXNzIHNob3VsZCBjb250YWluIGV4YWN0
-bHkgNCBwYXJ0cyIsbD0iZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIDAuLjI1NSIsaz1uZXcg
-UC5jUyhhKSxqPW5ldyBVaW50OEFycmF5KDQpCmZvcihzPWIscj1zLHE9MDtzPGM7KytzKXtwPUMueEIu
-TyhhLHMpCmlmKHAhPT00Nil7aWYoKHBeNDgpPjkpay4kMigiaW52YWxpZCBjaGFyYWN0ZXIiLHMpfWVs
-c2V7aWYocT09PTMpay4kMihtLHMpCm89UC5RQShDLnhCLk5qKGEscixzKSxudWxsKQppZihvPjI1NSlr
-LiQyKGwscikKbj1xKzEKaWYocT49NClyZXR1cm4gSC5PSChqLHEpCmpbcV09bwpyPXMrMQpxPW59fWlm
-KHEhPT0zKWsuJDIobSxjKQpvPVAuUUEoQy54Qi5OaihhLHIsYyksbnVsbCkKaWYobz4yNTUpay4kMihs
-LHIpCmlmKHE+PTQpcmV0dXJuIEguT0goaixxKQpqW3FdPW8KcmV0dXJuIGp9LAplZzpmdW5jdGlvbihh
-LGIsYTApe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZSxkPW5ldyBQLlZDKGEpLGM9bmV3
-IFAuSlQoZCxhKQppZihhLmxlbmd0aDwyKWQuJDEoImFkZHJlc3MgaXMgdG9vIHNob3J0IikKcz1ILlZN
-KFtdLHQuYSkKZm9yKHI9YixxPXIscD0hMSxvPSExO3I8YTA7KytyKXtuPUMueEIuTyhhLHIpCmlmKG49
-PT01OCl7aWYocj09PWIpeysrcgppZihDLnhCLk8oYSxyKSE9PTU4KWQuJDIoImludmFsaWQgc3RhcnQg
-Y29sb24uIixyKQpxPXJ9aWYocj09PXEpe2lmKHApZC4kMigib25seSBvbmUgd2lsZGNhcmQgYDo6YCBp
-cyBhbGxvd2VkIixyKQpDLk5tLmkocywtMSkKcD0hMH1lbHNlIEMuTm0uaShzLGMuJDIocSxyKSkKcT1y
-KzF9ZWxzZSBpZihuPT09NDYpbz0hMH1pZihzLmxlbmd0aD09PTApZC4kMSgidG9vIGZldyBwYXJ0cyIp
-Cm09cT09PWEwCmw9Qy5ObS5ncloocykKaWYobSYmbCE9PS0xKWQuJDIoImV4cGVjdGVkIGEgcGFydCBh
-ZnRlciBsYXN0IGA6YCIsYTApCmlmKCFtKWlmKCFvKUMuTm0uaShzLGMuJDIocSxhMCkpCmVsc2V7az1Q
-LkhoKGEscSxhMCkKQy5ObS5pKHMsKGtbMF08PDh8a1sxXSk+Pj4wKQpDLk5tLmkocywoa1syXTw8OHxr
-WzNdKT4+PjApfWlmKHApe2lmKHMubGVuZ3RoPjcpZC4kMSgiYW4gYWRkcmVzcyB3aXRoIGEgd2lsZGNh
-cmQgbXVzdCBoYXZlIGxlc3MgdGhhbiA3IHBhcnRzIil9ZWxzZSBpZihzLmxlbmd0aCE9PTgpZC4kMSgi
-YW4gYWRkcmVzcyB3aXRob3V0IGEgd2lsZGNhcmQgbXVzdCBjb250YWluIGV4YWN0bHkgOCBwYXJ0cyIp
-Cmo9bmV3IFVpbnQ4QXJyYXkoMTYpCmZvcihsPXMubGVuZ3RoLGk9OS1sLHI9MCxoPTA7cjxsOysrcil7
-Zz1zW3JdCmlmKGc9PT0tMSlmb3IoZj0wO2Y8aTsrK2Ype2lmKGg8MHx8aD49MTYpcmV0dXJuIEguT0go
-aixoKQpqW2hdPTAKZT1oKzEKaWYoZT49MTYpcmV0dXJuIEguT0goaixlKQpqW2VdPTAKaCs9Mn1lbHNl
-e2U9Qy5qbi53RyhnLDgpCmlmKGg8MHx8aD49MTYpcmV0dXJuIEguT0goaixoKQpqW2hdPWUKZT1oKzEK
-aWYoZT49MTYpcmV0dXJuIEguT0goaixlKQpqW2VdPWcmMjU1CmgrPTJ9fXJldHVybiBqfSwKQ2c6ZnVu
-Y3Rpb24oYSxiLGMsZCxlLGYsZyl7cmV0dXJuIG5ldyBQLkRuKGEsYixjLGQsZSxmLGcpfSwKS0w6ZnVu
-Y3Rpb24oYSxiLGMsZCxlLGYsZyl7dmFyIHMscixxLHAsbyxuCmY9Zj09bnVsbD8iIjpQLlBpKGYsMCxm
-Lmxlbmd0aCkKZz1QLnpSKGcsMCxnPT1udWxsPzA6Zy5sZW5ndGgpCmE9UC5PZShhLDAsYT09bnVsbD8w
-OmEubGVuZ3RoLCExKQpzPVAubGUobnVsbCwwLDAsZSkKcj1QLnRHKG51bGwsMCwwKQpkPVAud0IoZCxm
-KQpxPWY9PT0iZmlsZSIKaWYoYT09bnVsbClwPWcubGVuZ3RoIT09MHx8ZCE9bnVsbHx8cQplbHNlIHA9
-ITEKaWYocClhPSIiCnA9YT09bnVsbApvPSFwCmI9UC5rYShiLDAsYj09bnVsbD8wOmIubGVuZ3RoLGMs
-ZixvKQpuPWYubGVuZ3RoPT09MAppZihuJiZwJiYhQy54Qi5uQyhiLCIvIikpYj1QLndGKGIsIW58fG8p
-CmVsc2UgYj1QLnhlKGIpCnJldHVybiBQLkNnKGYsZyxwJiZDLnhCLm5DKGIsIi8vIik/IiI6YSxkLGIs
-cyxyKX0sCndLOmZ1bmN0aW9uKGEpe2lmKGE9PT0iaHR0cCIpcmV0dXJuIDgwCmlmKGE9PT0iaHR0cHMi
-KXJldHVybiA0NDMKcmV0dXJuIDB9LApOUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbgpmb3Io
-cz1hLmxlbmd0aCxyPTA7cjxzOysrcil7cT1DLnhCLlcoYSxyKQpwPUMueEIuVyhiLHIpCm89cV5wCmlm
-KG8hPT0wKXtpZihvPT09MzIpe249cHxvCmlmKDk3PD1uJiZuPD0xMjIpY29udGludWV9cmV0dXJuITF9
-fXJldHVybiEwfSwKUjM6ZnVuY3Rpb24oYSxiLGMpe3Rocm93IEguYihQLnJyKGMsYSxiKSl9LApYZDpm
-dW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGg9bnVsbCxnPWIubGVuZ3Ro
-CmlmKGchPT0wKXtxPTAKd2hpbGUoITApe2lmKCEocTxnKSl7cz0iIgpyPTAKYnJlYWt9aWYoQy54Qi5X
-KGIscSk9PT02NCl7cz1DLnhCLk5qKGIsMCxxKQpyPXErMQpicmVha30rK3F9aWYocjxnJiZDLnhCLlco
-YixyKT09PTkxKXtmb3IocD1yLG89LTE7cDxnOysrcCl7bj1DLnhCLlcoYixwKQppZihuPT09MzcmJm88
-MCl7bT1DLnhCLlFpKGIsIjI1IixwKzEpP3ArMjpwCm89cApwPW19ZWxzZSBpZihuPT09OTMpYnJlYWt9
-aWYocD09PWcpdGhyb3cgSC5iKFAucnIoIkludmFsaWQgSVB2NiBob3N0IGVudHJ5LiIsYixyKSkKbD1v
-PDA/cDpvClAuZWcoYixyKzEsbCk7KytwCmlmKHAhPT1nJiZDLnhCLlcoYixwKSE9PTU4KXRocm93IEgu
-YihQLnJyKCJJbnZhbGlkIGVuZCBvZiBhdXRob3JpdHkiLGIscCkpfWVsc2UgcD1yCndoaWxlKCEwKXtp
-ZighKHA8Zykpe2s9aApicmVha31pZihDLnhCLlcoYixwKT09PTU4KXtqPUMueEIueW4oYixwKzEpCms9
-ai5sZW5ndGghPT0wP1AuUUEoaixoKTpoCmJyZWFrfSsrcH1pPUMueEIuTmooYixyLHApfWVsc2V7az1o
-Cmk9awpzPSIifXJldHVybiBQLktMKGksaCxILlZNKGMuc3BsaXQoIi8iKSx0LnMpLGssZCxhLHMpfSwK
-a0U6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmZvcihzPUouSVQoYSk7cy5GKCk7KXtyPXMuZ2woKQpyLnRv
-U3RyaW5nCmlmKEguU1EociwiLyIsMCkpe3M9UC5MNCgiSWxsZWdhbCBwYXRoIGNoYXJhY3RlciAiK3Ip
-CnRocm93IEguYihzKX19fSwKSE46ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpmb3Iocz1KLkE1KGEs
-Yykscz1zLmdtKHMpO3MuRigpOyl7cj1zLmdsKCkKcT1QLm51KCdbIiovOjw+P1xcXFx8XScpCnIudG9T
-dHJpbmcKaWYoSC5TUShyLHEsMCkpe3M9UC5MNCgiSWxsZWdhbCBjaGFyYWN0ZXIgaW4gcGF0aDogIity
-KQp0aHJvdyBILmIocyl9fX0sCnJnOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoISg2NTw9YSYmYTw9OTAp
-KXM9OTc8PWEmJmE8PTEyMgplbHNlIHM9ITAKaWYocylyZXR1cm4Kcz1QLkw0KCJJbGxlZ2FsIGRyaXZl
-IGxldHRlciAiK1AuT28oYSkpCnRocm93IEguYihzKX0sCndCOmZ1bmN0aW9uKGEsYil7aWYoYSE9bnVs
-bCYmYT09PVAud0soYikpcmV0dXJuIG51bGwKcmV0dXJuIGF9LApPZTpmdW5jdGlvbihhLGIsYyxkKXt2
-YXIgcyxyLHEscCxvLG4KaWYoYT09bnVsbClyZXR1cm4gbnVsbAppZihiPT09YylyZXR1cm4iIgppZihD
-LnhCLk8oYSxiKT09PTkxKXtzPWMtMQppZihDLnhCLk8oYSxzKSE9PTkzKXtQLlIzKGEsYiwiTWlzc2lu
-ZyBlbmQgYF1gIHRvIG1hdGNoIGBbYCBpbiBob3N0IikKSC5CaSh1LmcpfXI9YisxCnE9UC50byhhLHIs
-cykKaWYocTxzKXtwPXErMQpvPVAuT0EoYSxDLnhCLlFpKGEsIjI1IixwKT9xKzM6cCxzLCIlMjUiKX1l
-bHNlIG89IiIKUC5lZyhhLHIscSkKcmV0dXJuIEMueEIuTmooYSxiLHEpLnRvTG93ZXJDYXNlKCkrbysi
-XSJ9Zm9yKG49YjtuPGM7KytuKWlmKEMueEIuTyhhLG4pPT09NTgpe3E9Qy54Qi5YVShhLCIlIixiKQpx
-PXE+PWImJnE8Yz9xOmMKaWYocTxjKXtwPXErMQpvPVAuT0EoYSxDLnhCLlFpKGEsIjI1IixwKT9xKzM6
-cCxjLCIlMjUiKX1lbHNlIG89IiIKUC5lZyhhLGIscSkKcmV0dXJuIlsiK0MueEIuTmooYSxiLHEpK28r
-Il0ifXJldHVybiBQLk9MKGEsYixjKX0sCnRvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1DLnhCLlhVKGEs
-IiUiLGIpCnJldHVybiBzPj1iJiZzPGM/czpjfSwKT0E6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixx
-LHAsbyxuLG0sbCxrLGosaT1kIT09IiI/bmV3IFAuUm4oZCk6bnVsbApmb3Iocz1iLHI9cyxxPSEwO3M8
-Yzspe3A9Qy54Qi5PKGEscykKaWYocD09PTM3KXtvPVAucnYoYSxzLCEwKQpuPW89PW51bGwKaWYobiYm
-cSl7cys9Mwpjb250aW51ZX1pZihpPT1udWxsKWk9bmV3IFAuUm4oIiIpCm09aS5hKz1DLnhCLk5qKGEs
-cixzKQppZihuKW89Qy54Qi5OaihhLHMscyszKQplbHNlIGlmKG89PT0iJSIpe1AuUjMoYSxzLCJab25l
-SUQgc2hvdWxkIG5vdCBjb250YWluICUgYW55bW9yZSIpCkguQmkodS5nKX1pLmE9bStvCnMrPTMKcj1z
-CnE9ITB9ZWxzZXtpZihwPDEyNyl7bj1wPj4+NAppZihuPj04KXJldHVybiBILk9IKEMuRjMsbikKbj0o
-Qy5GM1tuXSYxPDwocCYxNSkpIT09MH1lbHNlIG49ITEKaWYobil7aWYocSYmNjU8PXAmJjkwPj1wKXtp
-ZihpPT1udWxsKWk9bmV3IFAuUm4oIiIpCmlmKHI8cyl7aS5hKz1DLnhCLk5qKGEscixzKQpyPXN9cT0h
-MX0rK3N9ZWxzZXtpZigocCY2NDUxMik9PT01NTI5NiYmcysxPGMpe2w9Qy54Qi5PKGEscysxKQppZigo
-bCY2NDUxMik9PT01NjMyMCl7cD0ocCYxMDIzKTw8MTB8bCYxMDIzfDY1NTM2Cms9Mn1lbHNlIGs9MX1l
-bHNlIGs9MQpqPUMueEIuTmooYSxyLHMpCmlmKGk9PW51bGwpe2k9bmV3IFAuUm4oIiIpCm49aX1lbHNl
-IG49aQpuLmErPWoKbi5hKz1QLnpYKHApCnMrPWsKcj1zfX19aWYoaT09bnVsbClyZXR1cm4gQy54Qi5O
-aihhLGIsYykKaWYocjxjKWkuYSs9Qy54Qi5OaihhLHIsYykKbj1pLmEKcmV0dXJuIG4uY2hhckNvZGVB
-dCgwKT09MD9uOm59LApPTDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaQpm
-b3Iocz1iLHI9cyxxPW51bGwscD0hMDtzPGM7KXtvPUMueEIuTyhhLHMpCmlmKG89PT0zNyl7bj1QLnJ2
-KGEscywhMCkKbT1uPT1udWxsCmlmKG0mJnApe3MrPTMKY29udGludWV9aWYocT09bnVsbClxPW5ldyBQ
-LlJuKCIiKQpsPUMueEIuTmooYSxyLHMpCms9cS5hKz0hcD9sLnRvTG93ZXJDYXNlKCk6bAppZihtKXtu
-PUMueEIuTmooYSxzLHMrMykKaj0zfWVsc2UgaWYobj09PSIlIil7bj0iJTI1IgpqPTF9ZWxzZSBqPTMK
-cS5hPWsrbgpzKz1qCnI9cwpwPSEwfWVsc2V7aWYobzwxMjcpe209bz4+PjQKaWYobT49OClyZXR1cm4g
-SC5PSChDLmVhLG0pCm09KEMuZWFbbV0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSExCmlmKG0pe2lmKHAm
-JjY1PD1vJiY5MD49byl7aWYocT09bnVsbClxPW5ldyBQLlJuKCIiKQppZihyPHMpe3EuYSs9Qy54Qi5O
-aihhLHIscykKcj1zfXA9ITF9KytzfWVsc2V7aWYobzw9OTMpe209bz4+PjQKaWYobT49OClyZXR1cm4g
-SC5PSChDLmFrLG0pCm09KEMuYWtbbV0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSExCmlmKG0pe1AuUjMo
-YSxzLCJJbnZhbGlkIGNoYXJhY3RlciIpCkguQmkodS5nKX1lbHNle2lmKChvJjY0NTEyKT09PTU1Mjk2
-JiZzKzE8Yyl7aT1DLnhCLk8oYSxzKzEpCmlmKChpJjY0NTEyKT09PTU2MzIwKXtvPShvJjEwMjMpPDwx
-MHxpJjEwMjN8NjU1MzYKaj0yfWVsc2Ugaj0xfWVsc2Ugaj0xCmw9Qy54Qi5OaihhLHIscykKaWYoIXAp
-bD1sLnRvTG93ZXJDYXNlKCkKaWYocT09bnVsbCl7cT1uZXcgUC5SbigiIikKbT1xfWVsc2UgbT1xCm0u
-YSs9bAptLmErPVAuelgobykKcys9agpyPXN9fX19aWYocT09bnVsbClyZXR1cm4gQy54Qi5OaihhLGIs
-YykKaWYocjxjKXtsPUMueEIuTmooYSxyLGMpCnEuYSs9IXA/bC50b0xvd2VyQ2FzZSgpOmx9bT1xLmEK
-cmV0dXJuIG0uY2hhckNvZGVBdCgwKT09MD9tOm19LApQaTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixx
-LHAsbz11LmcKaWYoYj09PWMpcmV0dXJuIiIKaWYoIVAuRXQoSi5ReihhLGIpKSl7UC5SMyhhLGIsIlNj
-aGVtZSBub3Qgc3RhcnRpbmcgd2l0aCBhbHBoYWJldGljIGNoYXJhY3RlciIpCkguQmkobyl9Zm9yKHM9
-YixyPSExO3M8YzsrK3Mpe3E9Qy54Qi5XKGEscykKaWYocTwxMjgpe3A9cT4+PjQKaWYocD49OClyZXR1
-cm4gSC5PSChDLm1LLHApCnA9KEMubUtbcF0mMTw8KHEmMTUpKSE9PTB9ZWxzZSBwPSExCmlmKCFwKXtQ
-LlIzKGEscywiSWxsZWdhbCBzY2hlbWUgY2hhcmFjdGVyIikKSC5CaShvKX1pZig2NTw9cSYmcTw9OTAp
-cj0hMH1hPUMueEIuTmooYSxiLGMpCnJldHVybiBQLllhKHI/YS50b0xvd2VyQ2FzZSgpOmEpfSwKWWE6
-ZnVuY3Rpb24oYSl7aWYoYT09PSJodHRwIilyZXR1cm4iaHR0cCIKaWYoYT09PSJmaWxlIilyZXR1cm4i
-ZmlsZSIKaWYoYT09PSJodHRwcyIpcmV0dXJuImh0dHBzIgppZihhPT09InBhY2thZ2UiKXJldHVybiJw
-YWNrYWdlIgpyZXR1cm4gYX0sCnpSOmZ1bmN0aW9uKGEsYixjKXtpZihhPT1udWxsKXJldHVybiIiCnJl
-dHVybiBQLlBJKGEsYixjLEMudG8sITEpfSwKa2E6ZnVuY3Rpb24oYSxiLGMsZCxlLGYpe3ZhciBzLHIs
-cT1lPT09ImZpbGUiLHA9cXx8ZgppZihhPT1udWxsKXtpZihkPT1udWxsKXJldHVybiBxPyIvIjoiIgpz
-PUgudDYoZCkKcj1uZXcgSC5sSihkLHMuQygicVUoMSkiKS5hKG5ldyBQLlJaKCkpLHMuQygibEo8MSxx
-VT4iKSkuaygwLCIvIil9ZWxzZSBpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJCb3RoIHBhdGggYW5k
-IHBhdGhTZWdtZW50cyBzcGVjaWZpZWQiKSkKZWxzZSByPVAuUEkoYSxiLGMsQy5XZCwhMCkKaWYoci5s
-ZW5ndGg9PT0wKXtpZihxKXJldHVybiIvIn1lbHNlIGlmKHAmJiFDLnhCLm5DKHIsIi8iKSlyPSIvIity
-CnJldHVybiBQLkpyKHIsZSxmKX0sCkpyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1iLmxlbmd0aD09PTAK
-aWYocyYmIWMmJiFDLnhCLm5DKGEsIi8iKSlyZXR1cm4gUC53RihhLCFzfHxjKQpyZXR1cm4gUC54ZShh
-KX0sCmxlOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9e30KaWYoYSE9bnVsbCl7aWYoZCE9bnVsbCl0
-aHJvdyBILmIoUC54WSgiQm90aCBxdWVyeSBhbmQgcXVlcnlQYXJhbWV0ZXJzIHNwZWNpZmllZCIpKQpy
-ZXR1cm4gUC5QSShhLGIsYyxDLlZDLCEwKX1pZihkPT1udWxsKXJldHVybiBudWxsCnM9bmV3IFAuUm4o
-IiIpCnIuYT0iIgpkLksoMCxuZXcgUC55NShuZXcgUC5NRShyLHMpKSkKcj1zLmEKcmV0dXJuIHIuY2hh
-ckNvZGVBdCgwKT09MD9yOnJ9LAp0RzpmdW5jdGlvbihhLGIsYyl7aWYoYT09bnVsbClyZXR1cm4gbnVs
-bApyZXR1cm4gUC5QSShhLGIsYyxDLlZDLCEwKX0sCnJ2OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEs
-cCxvLG49YisyCmlmKG4+PWEubGVuZ3RoKXJldHVybiIlIgpzPUMueEIuTyhhLGIrMSkKcj1DLnhCLk8o
-YSxuKQpxPUgub28ocykKcD1ILm9vKHIpCmlmKHE8MHx8cDwwKXJldHVybiIlIgpvPXEqMTYrcAppZihv
-PDEyNyl7bj1DLmpuLndHKG8sNCkKaWYobj49OClyZXR1cm4gSC5PSChDLkYzLG4pCm49KEMuRjNbbl0m
-MTw8KG8mMTUpKSE9PTB9ZWxzZSBuPSExCmlmKG4pcmV0dXJuIEguTHcoYyYmNjU8PW8mJjkwPj1vPyhv
-fDMyKT4+PjA6bykKaWYocz49OTd8fHI+PTk3KXJldHVybiBDLnhCLk5qKGEsYixiKzMpLnRvVXBwZXJD
-YXNlKCkKcmV0dXJuIG51bGx9LAp6WDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9IjAx
-MjM0NTY3ODlBQkNERUYiCmlmKGE8MTI4KXtzPW5ldyBVaW50OEFycmF5KDMpCnNbMF09MzcKc1sxXT1D
-LnhCLlcoayxhPj4+NCkKc1syXT1DLnhCLlcoayxhJjE1KX1lbHNle2lmKGE+MjA0NylpZihhPjY1NTM1
-KXtyPTI0MApxPTR9ZWxzZXtyPTIyNApxPTN9ZWxzZXtyPTE5MgpxPTJ9cD0zKnEKcz1uZXcgVWludDhB
-cnJheShwKQpmb3Iobz0wOy0tcSxxPj0wO3I9MTI4KXtuPUMuam4uYmYoYSw2KnEpJjYzfHIKaWYobz49
-cClyZXR1cm4gSC5PSChzLG8pCnNbb109MzcKbT1vKzEKbD1DLnhCLlcoayxuPj4+NCkKaWYobT49cCly
-ZXR1cm4gSC5PSChzLG0pCnNbbV09bApsPW8rMgptPUMueEIuVyhrLG4mMTUpCmlmKGw+PXApcmV0dXJu
-IEguT0gocyxsKQpzW2xdPW0Kbys9M319cmV0dXJuIFAuSE0ocywwLG51bGwpfSwKUEk6ZnVuY3Rpb24o
-YSxiLGMsZCxlKXt2YXIgcz1QLlVsKGEsYixjLGQsZSkKcmV0dXJuIHM9PW51bGw/Qy54Qi5OaihhLGIs
-Yyk6c30sClVsOmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGo9bnVsbApm
-b3Iocz0hZSxyPWIscT1yLHA9ajtyPGM7KXtvPUMueEIuTyhhLHIpCmlmKG88MTI3KXtuPW8+Pj40Cmlm
-KG4+PTgpcmV0dXJuIEguT0goZCxuKQpuPShkW25dJjE8PChvJjE1KSkhPT0wfWVsc2Ugbj0hMQppZihu
-KSsrcgplbHNle2lmKG89PT0zNyl7bT1QLnJ2KGEsciwhMSkKaWYobT09bnVsbCl7cis9Mwpjb250aW51
-ZX1pZigiJSI9PT1tKXttPSIlMjUiCmw9MX1lbHNlIGw9M31lbHNle2lmKHMpaWYobzw9OTMpe249bz4+
-PjQKaWYobj49OClyZXR1cm4gSC5PSChDLmFrLG4pCm49KEMuYWtbbl0mMTw8KG8mMTUpKSE9PTB9ZWxz
-ZSBuPSExCmVsc2Ugbj0hMQppZihuKXtQLlIzKGEsciwiSW52YWxpZCBjaGFyYWN0ZXIiKQpILkJpKHUu
-ZykKbD1qCm09bH1lbHNle2lmKChvJjY0NTEyKT09PTU1Mjk2KXtuPXIrMQppZihuPGMpe2s9Qy54Qi5P
-KGEsbikKaWYoKGsmNjQ1MTIpPT09NTYzMjApe289KG8mMTAyMyk8PDEwfGsmMTAyM3w2NTUzNgpsPTJ9
-ZWxzZSBsPTF9ZWxzZSBsPTF9ZWxzZSBsPTEKbT1QLnpYKG8pfX1pZihwPT1udWxsKXtwPW5ldyBQLlJu
-KCIiKQpuPXB9ZWxzZSBuPXAKbi5hKz1DLnhCLk5qKGEscSxyKQpuLmErPUguRWoobSkKaWYodHlwZW9m
-IGwhPT0ibnVtYmVyIilyZXR1cm4gSC5wWShsKQpyKz1sCnE9cn19aWYocD09bnVsbClyZXR1cm4gagpp
-ZihxPGMpcC5hKz1DLnhCLk5qKGEscSxjKQpzPXAuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6
-c30sCnlCOmZ1bmN0aW9uKGEpe2lmKEMueEIubkMoYSwiLiIpKXJldHVybiEwCnJldHVybiBDLnhCLk9Z
-KGEsIi8uIikhPT0tMX0sCnhlOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtCmlmKCFQLnlCKGEp
-KXJldHVybiBhCnM9SC5WTShbXSx0LnMpCmZvcihyPWEuc3BsaXQoIi8iKSxxPXIubGVuZ3RoLHA9ITEs
-bz0wO288cTsrK28pe249cltvXQppZihKLlJNKG4sIi4uIikpe209cy5sZW5ndGgKaWYobSE9PTApe2lm
-KDA+PW0pcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQppZihzLmxlbmd0aD09PTApQy5ObS5pKHMsIiIp
-fXA9ITB9ZWxzZSBpZigiLiI9PT1uKXA9ITAKZWxzZXtDLk5tLmkocyxuKQpwPSExfX1pZihwKUMuTm0u
-aShzLCIiKQpyZXR1cm4gQy5ObS5rKHMsIi8iKX0sCndGOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAs
-byxuCmlmKCFQLnlCKGEpKXJldHVybiFiP1AuQzEoYSk6YQpzPUguVk0oW10sdC5zKQpmb3Iocj1hLnNw
-bGl0KCIvIikscT1yLmxlbmd0aCxwPSExLG89MDtvPHE7KytvKXtuPXJbb10KaWYoIi4uIj09PW4paWYo
-cy5sZW5ndGghPT0wJiZDLk5tLmdyWihzKSE9PSIuLiIpe2lmKDA+PXMubGVuZ3RoKXJldHVybiBILk9I
-KHMsLTEpCnMucG9wKCkKcD0hMH1lbHNle0MuTm0uaShzLCIuLiIpCnA9ITF9ZWxzZSBpZigiLiI9PT1u
-KXA9ITAKZWxzZXtDLk5tLmkocyxuKQpwPSExfX1yPXMubGVuZ3RoCmlmKHIhPT0wKWlmKHI9PT0xKXtp
-ZigwPj1yKXJldHVybiBILk9IKHMsMCkKcj1zWzBdLmxlbmd0aD09PTB9ZWxzZSByPSExCmVsc2Ugcj0h
-MAppZihyKXJldHVybiIuLyIKaWYocHx8Qy5ObS5ncloocyk9PT0iLi4iKUMuTm0uaShzLCIiKQppZigh
-Yil7aWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywwKQpDLk5tLlk1KHMsMCxQLkMxKHNbMF0pKX1y
-ZXR1cm4gQy5ObS5rKHMsIi8iKX0sCkMxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEubGVuZ3RoCmlm
-KHA+PTImJlAuRXQoSi5ReihhLDApKSlmb3Iocz0xO3M8cDsrK3Mpe3I9Qy54Qi5XKGEscykKaWYocj09
-PTU4KXJldHVybiBDLnhCLk5qKGEsMCxzKSsiJTNBIitDLnhCLnluKGEscysxKQppZihyPD0xMjcpe3E9
-cj4+PjQKaWYocT49OClyZXR1cm4gSC5PSChDLm1LLHEpCnE9KEMubUtbcV0mMTw8KHImMTUpKT09PTB9
-ZWxzZSBxPSEwCmlmKHEpYnJlYWt9cmV0dXJuIGF9LAp1ajpmdW5jdGlvbihhLGIpe2lmKGEuaEIoInBh
-Y2thZ2UiKSYmYS5jPT1udWxsKXJldHVybiBQLmZGKGIsMCxiLmxlbmd0aCkKcmV0dXJuLTF9LAptbjpm
-dW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLmdGaigpLG89Si5VNihwKQppZihvLmdBKHApPjAmJkouSG0o
-by5xKHAsMCkpPT09MiYmSi5hNihvLnEocCwwKSwxKT09PTU4KXtQLnJnKEouYTYoby5xKHAsMCksMCks
-ITEpClAuSE4ocCwhMSwxKQpzPSEwfWVsc2V7UC5ITihwLCExLDApCnM9ITF9cj1hLmd0VCgpJiYhcz8i
-XFwiOiIiCmlmKGEuZ2NqKCkpe3E9YS5nSmYoYSkKaWYocS5sZW5ndGghPT0wKXI9cisiXFwiK3ErIlxc
-In1yPVAudmcocixwLCJcXCIpCm89cyYmby5nQShwKT09PTE/cisiXFwiOnIKcmV0dXJuIG8uY2hhckNv
-ZGVBdCgwKT09MD9vOm99LApJaDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpmb3Iocz0wLHI9MDtyPDI7
-KytyKXtxPUMueEIuVyhhLGIrcikKaWYoNDg8PXEmJnE8PTU3KXM9cyoxNitxLTQ4CmVsc2V7cXw9MzIK
-aWYoOTc8PXEmJnE8PTEwMilzPXMqMTYrcS04NwplbHNlIHRocm93IEguYihQLnhZKCJJbnZhbGlkIFVS
-TCBlbmNvZGluZyIpKX19cmV0dXJuIHN9LAprdTpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxw
-LG89Si5yWShhKSxuPWIKd2hpbGUoITApe2lmKCEobjxjKSl7cz0hMApicmVha31yPW8uVyhhLG4pCmlm
-KHI8PTEyNylpZihyIT09MzcpcT1lJiZyPT09NDMKZWxzZSBxPSEwCmVsc2UgcT0hMAppZihxKXtzPSEx
-CmJyZWFrfSsrbn1pZihzKXtpZihDLnhNIT09ZClxPSExCmVsc2UgcT0hMAppZihxKXJldHVybiBvLk5q
-KGEsYixjKQplbHNlIHA9bmV3IEgucWooby5OaihhLGIsYykpfWVsc2V7cD1ILlZNKFtdLHQuYSkKZm9y
-KG49YjtuPGM7KytuKXtyPW8uVyhhLG4pCmlmKHI+MTI3KXRocm93IEguYihQLnhZKCJJbGxlZ2FsIHBl
-cmNlbnQgZW5jb2RpbmcgaW4gVVJJIikpCmlmKHI9PT0zNyl7aWYobiszPmEubGVuZ3RoKXRocm93IEgu
-YihQLnhZKCJUcnVuY2F0ZWQgVVJJIikpCkMuTm0uaShwLFAuSWgoYSxuKzEpKQpuKz0yfWVsc2UgaWYo
-ZSYmcj09PTQzKUMuTm0uaShwLDMyKQplbHNlIEMuTm0uaShwLHIpfX10LkwuYShwKQpyZXR1cm4gQy5v
-RS5XSihwKX0sCkV0OmZ1bmN0aW9uKGEpe3ZhciBzPWF8MzIKcmV0dXJuIDk3PD1zJiZzPD0xMjJ9LApL
-RDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbCxrPSJJbnZhbGlkIE1JTUUgdHlwZSIs
-aj1ILlZNKFtiLTFdLHQuYSkKZm9yKHM9YS5sZW5ndGgscj1iLHE9LTEscD1udWxsO3I8czsrK3Ipe3A9
-Qy54Qi5XKGEscikKaWYocD09PTQ0fHxwPT09NTkpYnJlYWsKaWYocD09PTQ3KXtpZihxPDApe3E9cgpj
-b250aW51ZX10aHJvdyBILmIoUC5ycihrLGEscikpfX1pZihxPDAmJnI+Yil0aHJvdyBILmIoUC5ycihr
-LGEscikpCmZvcig7cCE9PTQ0Oyl7Qy5ObS5pKGoscik7KytyCmZvcihvPS0xO3I8czsrK3Ipe3A9Qy54
-Qi5XKGEscikKaWYocD09PTYxKXtpZihvPDApbz1yfWVsc2UgaWYocD09PTU5fHxwPT09NDQpYnJlYWt9
-aWYobz49MClDLk5tLmkoaixvKQplbHNle249Qy5ObS5nclooaikKaWYocCE9PTQ0fHxyIT09bis3fHwh
-Qy54Qi5RaShhLCJiYXNlNjQiLG4rMSkpdGhyb3cgSC5iKFAucnIoIkV4cGVjdGluZyAnPSciLGEscikp
-CmJyZWFrfX1DLk5tLmkoaixyKQptPXIrMQppZigoai5sZW5ndGgmMSk9PT0xKWE9Qy5oOS55cihhLG0s
-cykKZWxzZXtsPVAuVWwoYSxtLHMsQy5WQywhMCkKaWYobCE9bnVsbClhPUMueEIuaTcoYSxtLHMsbCl9
-cmV0dXJuIG5ldyBQLlBFKGEsaixjKX0sCktOOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09IjAx
-MjM0NTY3ODlBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6
-LS5ffiEkJicoKSorLDs9IixsPSIuIixrPSI6IixqPSIvIixpPSI/IixoPSIjIixnPUguVk0obmV3IEFy
-cmF5KDIyKSx0LmdOKQpmb3Iocz0wO3M8MjI7KytzKWdbc109bmV3IFVpbnQ4QXJyYXkoOTYpCnI9bmV3
-IFAueUkoZykKcT1uZXcgUC5jNigpCnA9bmV3IFAucWQoKQpvPXQuZ2MKbj1vLmEoci4kMigwLDIyNSkp
-CnEuJDMobixtLDEpCnEuJDMobixsLDE0KQpxLiQzKG4saywzNCkKcS4kMyhuLGosMykKcS4kMyhuLGks
-MTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTQsMjI1KSkKcS4kMyhuLG0sMSkKcS4kMyhuLGws
-MTUpCnEuJDMobixrLDM0KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpu
-PW8uYShyLiQyKDE1LDIyNSkpCnEuJDMobixtLDEpCnEuJDMobiwiJSIsMjI1KQpxLiQzKG4saywzNCkK
-cS4kMyhuLGosOSkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMSwyMjUpKQpx
-LiQzKG4sbSwxKQpxLiQzKG4saywzNCkKcS4kMyhuLGosMTApCnEuJDMobixpLDE3MikKcS4kMyhuLGgs
-MjA1KQpuPW8uYShyLiQyKDIsMjM1KSkKcS4kMyhuLG0sMTM5KQpxLiQzKG4saiwxMzEpCnEuJDMobixs
-LDE0NikKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMywyMzUpKQpxLiQzKG4s
-bSwxMSkKcS4kMyhuLGosNjgpCnEuJDMobixsLDE4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkK
-bj1vLmEoci4kMig0LDIyOSkpCnEuJDMobixtLDUpCnAuJDMobiwiQVoiLDIyOSkKcS4kMyhuLGssMTAy
-KQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4sIlsiLDIzMikKcS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIp
-CnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig1LDIyOSkpCnEuJDMobixtLDUpCnAuJDMobiwiQVoiLDIy
-OSkKcS4kMyhuLGssMTAyKQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4saiwxMzgpCnEuJDMobixpLDE3MikK
-cS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDYsMjMxKSkKcC4kMyhuLCIxOSIsNykKcS4kMyhuLCJAIiw2
-OCkKcS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig3LDIz
-MSkpCnAuJDMobiwiMDkiLDcpCnEuJDMobiwiQCIsNjgpCnEuJDMobixqLDEzOCkKcS4kMyhuLGksMTcy
-KQpxLiQzKG4saCwyMDUpCnEuJDMoby5hKHIuJDIoOCw4KSksIl0iLDUpCm49by5hKHIuJDIoOSwyMzUp
-KQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTYpCnEuJDMobixqLDIzNCkKcS4kMyhuLGksMTcyKQpxLiQz
-KG4saCwyMDUpCm49by5hKHIuJDIoMTYsMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixsLDE3KQpxLiQz
-KG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDE3LDIzNSkpCnEu
-JDMobixtLDExKQpxLiQzKG4saiw5KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4k
-MigxMCwyMzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTgpCnEuJDMobixqLDIzNCkKcS4kMyhuLGks
-MTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTgsMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixs
-LDE5KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDE5
-LDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1
-KQpuPW8uYShyLiQyKDExLDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiwxMCkKcS4kMyhuLGksMTcy
-KQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTIsMjM2KSkKcS4kMyhuLG0sMTIpCnEuJDMobixpLDEy
-KQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTMsMjM3KSkKcS4kMyhuLG0sMTMpCnEuJDMobixpLDEz
-KQpwLiQzKG8uYShyLiQyKDIwLDI0NSkpLCJheiIsMjEpCnI9by5hKHIuJDIoMjEsMjQ1KSkKcC4kMyhy
-LCJheiIsMjEpCnAuJDMociwiMDkiLDIxKQpxLiQzKHIsIistLiIsMjEpCnJldHVybiBnfSwKVUI6ZnVu
-Y3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvLG49JC52WigpCmZvcihzPUouclkoYSkscj1iO3I8
-YzsrK3Ipe2lmKGQ8MHx8ZD49bi5sZW5ndGgpcmV0dXJuIEguT0gobixkKQpxPW5bZF0KcD1zLlcoYSxy
-KV45NgpvPXFbcD45NT8zMTpwXQpkPW8mMzEKQy5ObS5ZNShlLG8+Pj41LHIpfXJldHVybiBkfSwKUng6
-ZnVuY3Rpb24oYSl7aWYoYS5iPT09NyYmQy54Qi5uQyhhLmEsInBhY2thZ2UiKSYmYS5jPD0wKXJldHVy
-biBQLmZGKGEuYSxhLmUsYS5mKQpyZXR1cm4tMX0sCmZGOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEK
-Zm9yKHM9YixyPTA7czxjOysrcyl7cT1DLnhCLk8oYSxzKQppZihxPT09NDcpcmV0dXJuIHIhPT0wP3M6
-LTEKaWYocT09PTM3fHxxPT09NTgpcmV0dXJuLTEKcnw9cV40Nn1yZXR1cm4tMX0sCldGOmZ1bmN0aW9u
-IFdGKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LAppUDpmdW5jdGlvbiBpUChhLGIpe3RoaXMuYT1hCnRo
-aXMuYj1ifSwKWFM6ZnVuY3Rpb24gWFMoKXt9LApDNjpmdW5jdGlvbiBDNihhKXt0aGlzLmE9YX0sCkV6
-OmZ1bmN0aW9uIEV6KCl7fSwKRjpmdW5jdGlvbiBGKCl7fSwKdTpmdW5jdGlvbiB1KGEsYixjLGQpe3Zh
-ciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWR9LApiSjpmdW5jdGlvbiBiSihhLGIsYyxkLGUs
-Zil7dmFyIF89dGhpcwpfLmU9YQpfLmY9YgpfLmE9YwpfLmI9ZApfLmM9ZQpfLmQ9Zn0sCmVZOmZ1bmN0
-aW9uIGVZKGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmY9YQpfLmE9YgpfLmI9YwpfLmM9ZApfLmQ9ZX0s
-Cm1wOmZ1bmN0aW9uIG1wKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWR9
-LAp1YjpmdW5jdGlvbiB1YihhKXt0aGlzLmE9YX0sCmRzOmZ1bmN0aW9uIGRzKGEpe3RoaXMuYT1hfSwK
-bGo6ZnVuY3Rpb24gbGooYSl7dGhpcy5hPWF9LApVVjpmdW5jdGlvbiBVVihhKXt0aGlzLmE9YX0sCms1
-OmZ1bmN0aW9uIGs1KCl7fSwKS1k6ZnVuY3Rpb24gS1koKXt9LApjOmZ1bmN0aW9uIGMoYSl7dGhpcy5h
-PWF9LApDRDpmdW5jdGlvbiBDRChhKXt0aGlzLmE9YX0sCmFFOmZ1bmN0aW9uIGFFKGEsYixjKXt0aGlz
-LmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCmNYOmZ1bmN0aW9uIGNYKCl7fSwKQW46ZnVuY3Rpb24gQW4o
-KXt9LApOMzpmdW5jdGlvbiBOMyhhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy4kdGk9Y30sCmM4
-OmZ1bmN0aW9uIGM4KCl7fSwKTWg6ZnVuY3Rpb24gTWgoKXt9LApaZDpmdW5jdGlvbiBaZCgpe30sClJu
-OmZ1bmN0aW9uIFJuKGEpe3RoaXMuYT1hfSwKbjE6ZnVuY3Rpb24gbjEoYSl7dGhpcy5hPWF9LApjUzpm
-dW5jdGlvbiBjUyhhKXt0aGlzLmE9YX0sClZDOmZ1bmN0aW9uIFZDKGEpe3RoaXMuYT1hfSwKSlQ6ZnVu
-Y3Rpb24gSlQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkRuOmZ1bmN0aW9uIERuKGEsYixjLGQsZSxm
-LGcpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5mPWYKXy5yPWcKXy5R
-PV8uej1fLnk9Xy54PSR9LApSWjpmdW5jdGlvbiBSWigpe30sCk1FOmZ1bmN0aW9uIE1FKGEsYil7dGhp
-cy5hPWEKdGhpcy5iPWJ9LAp5NTpmdW5jdGlvbiB5NShhKXt0aGlzLmE9YX0sClBFOmZ1bmN0aW9uIFBF
-KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCnlJOmZ1bmN0aW9uIHlJKGEpe3RoaXMu
-YT1hfSwKYzY6ZnVuY3Rpb24gYzYoKXt9LApxZDpmdW5jdGlvbiBxZCgpe30sClVmOmZ1bmN0aW9uIFVm
-KGEsYixjLGQsZSxmLGcsaCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZApfLmU9ZQpf
-LmY9ZgpfLnI9ZwpfLng9aApfLnk9bnVsbH0sCnFlOmZ1bmN0aW9uIHFlKGEsYixjLGQsZSxmLGcpe3Zh
-ciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5mPWYKXy5yPWcKXy5RPV8uej1f
-Lnk9Xy54PSR9LAppSjpmdW5jdGlvbiBpSigpe30sCmpnOmZ1bmN0aW9uIGpnKGEsYil7dGhpcy5hPWEK
-dGhpcy5iPWJ9LApUYTpmdW5jdGlvbiBUYShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKQmY6ZnVuY3Rp
-b24gQmYoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkFzOmZ1bmN0aW9uIEFzKCl7fSwKR0U6ZnVuY3Rp
-b24gR0UoYSl7dGhpcy5hPWF9LApONzpmdW5jdGlvbiBONyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwK
-dVE6ZnVuY3Rpb24gdVEoKXt9LApoRjpmdW5jdGlvbiBoRigpe30sClI0OmZ1bmN0aW9uKGEsYixjLGQp
-e3ZhciBzLHIscQpILnk4KGIpCnQuai5hKGQpCmlmKEgub1QoYikpe3M9W2NdCkMuTm0uRlYocyxkKQpk
-PXN9cj10LnoKcT1QLkNIKEouTTEoZCxQLncwKCksciksITAscikKdC5ZLmEoYSkKcmV0dXJuIFAud1ko
-SC5FayhhLHEsbnVsbCkpfSwKRG06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCnRyeXtpZihPYmplY3QuaXNF
-eHRlbnNpYmxlKGEpJiYhT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKGEsYikpe09i
-amVjdC5kZWZpbmVQcm9wZXJ0eShhLGIse3ZhbHVlOmN9KQpyZXR1cm4hMH19Y2F0Y2gocyl7SC5SdShz
-KX1yZXR1cm4hMX0sCk9tOmZ1bmN0aW9uKGEsYil7aWYoT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9w
-ZXJ0eS5jYWxsKGEsYikpcmV0dXJuIGFbYl0KcmV0dXJuIG51bGx9LAp3WTpmdW5jdGlvbihhKXtpZihh
-PT1udWxsfHx0eXBlb2YgYT09InN0cmluZyJ8fHR5cGVvZiBhPT0ibnVtYmVyInx8SC5sKGEpKXJldHVy
-biBhCmlmKGEgaW5zdGFuY2VvZiBQLkU0KXJldHVybiBhLmEKaWYoSC5SOShhKSlyZXR1cm4gYQppZih0
-LmFrLmIoYSkpcmV0dXJuIGEKaWYoYSBpbnN0YW5jZW9mIFAuaVApcmV0dXJuIEgubzIoYSkKaWYodC5Z
-LmIoYSkpcmV0dXJuIFAuaEUoYSwiJGRhcnRfanNGdW5jdGlvbiIsbmV3IFAuUEMoKSkKcmV0dXJuIFAu
-aEUoYSwiXyRkYXJ0X2pzT2JqZWN0IixuZXcgUC5tdCgkLmtJKCkpKX0sCmhFOmZ1bmN0aW9uKGEsYixj
-KXt2YXIgcz1QLk9tKGEsYikKaWYocz09bnVsbCl7cz1jLiQxKGEpClAuRG0oYSxiLHMpfXJldHVybiBz
-fSwKZFU6ZnVuY3Rpb24oYSl7dmFyIHMscgppZihhPT1udWxsfHx0eXBlb2YgYT09InN0cmluZyJ8fHR5
-cGVvZiBhPT0ibnVtYmVyInx8dHlwZW9mIGE9PSJib29sZWFuIilyZXR1cm4gYQplbHNlIGlmKGEgaW5z
-dGFuY2VvZiBPYmplY3QmJkguUjkoYSkpcmV0dXJuIGEKZWxzZSBpZihhIGluc3RhbmNlb2YgT2JqZWN0
-JiZ0LmFrLmIoYSkpcmV0dXJuIGEKZWxzZSBpZihhIGluc3RhbmNlb2YgRGF0ZSl7cz1ILnVQKGEuZ2V0
-VGltZSgpKQppZihNYXRoLmFicyhzKTw9ODY0ZTEzKXI9ITEKZWxzZSByPSEwCmlmKHIpSC52KFAueFko
-IkRhdGVUaW1lIGlzIG91dHNpZGUgdmFsaWQgcmFuZ2U6ICIrcykpCkguY2IoITEsImlzVXRjIix0Lnkp
-CnJldHVybiBuZXcgUC5pUChzLCExKX1lbHNlIGlmKGEuY29uc3RydWN0b3I9PT0kLmtJKCkpcmV0dXJu
-IGEubwplbHNlIHJldHVybiBQLk5EKGEpfSwKTkQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJmdW5j
-dGlvbiIpcmV0dXJuIFAuaVEoYSwkLncoKSxuZXcgUC5RUygpKQppZihhIGluc3RhbmNlb2YgQXJyYXkp
-cmV0dXJuIFAuaVEoYSwkLlI4KCksbmV3IFAubnAoKSkKcmV0dXJuIFAuaVEoYSwkLlI4KCksbmV3IFAu
-VXQoKSl9LAppUTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9UC5PbShhLGIpCmlmKHM9PW51bGx8fCEoYSBp
-bnN0YW5jZW9mIE9iamVjdCkpe3M9Yy4kMShhKQpQLkRtKGEsYixzKX1yZXR1cm4gc30sClBDOmZ1bmN0
-aW9uIFBDKCl7fSwKbXQ6ZnVuY3Rpb24gbXQoYSl7dGhpcy5hPWF9LApRUzpmdW5jdGlvbiBRUygpe30s
-Cm5wOmZ1bmN0aW9uIG5wKCl7fSwKVXQ6ZnVuY3Rpb24gVXQoKXt9LApFNDpmdW5jdGlvbiBFNChhKXt0
-aGlzLmE9YX0sCnI3OmZ1bmN0aW9uIHI3KGEpe3RoaXMuYT1hfSwKVHo6ZnVuY3Rpb24gVHooYSxiKXt0
-aGlzLmE9YQp0aGlzLiR0aT1ifSwKY286ZnVuY3Rpb24gY28oKXt9LApuZDpmdW5jdGlvbiBuZCgpe30s
-CktlOmZ1bmN0aW9uIEtlKGEpe3RoaXMuYT1hfSwKaGk6ZnVuY3Rpb24gaGkoKXt9fSxXPXsKeDM6ZnVu
-Y3Rpb24oKXtyZXR1cm4gd2luZG93fSwKWnI6ZnVuY3Rpb24oKXtyZXR1cm4gZG9jdW1lbnR9LApKNjpm
-dW5jdGlvbihhKXt2YXIgcz1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCJhIikKaWYoYSE9bnVsbClDLnhu
-LnNMVShzLGEpCnJldHVybiBzfSwKTGo6ZnVuY3Rpb24oYSl7cmV0dXJuIENTUy5lc2NhcGUoYSl9LApV
-OTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscj1kb2N1bWVudC5ib2R5CnIudG9TdHJpbmcKcz1DLlJZLnI2
-KHIsYSxiLGMpCnMudG9TdHJpbmcKcj10LmFjCnI9bmV3IEguVTUobmV3IFcuZTcocyksci5DKCJhMihs
-RC5FKSIpLmEobmV3IFcuQ3YoKSksci5DKCJVNTxsRC5FPiIpKQpyZXR1cm4gdC5oLmEoci5ncjgocikp
-fSwKclM6ZnVuY3Rpb24oYSl7dmFyIHMscixxPSJlbGVtZW50IHRhZyB1bmF2YWlsYWJsZSIKdHJ5e3M9
-Si5ZRShhKQppZih0eXBlb2Ygcy5nbnMoYSk9PSJzdHJpbmciKXE9cy5nbnMoYSl9Y2F0Y2gocil7SC5S
-dShyKX1yZXR1cm4gcX0sCkMwOmZ1bmN0aW9uKGEsYil7YT1hK2ImNTM2ODcwOTExCmE9YSsoKGEmNTI0
-Mjg3KTw8MTApJjUzNjg3MDkxMQpyZXR1cm4gYV5hPj4+Nn0sCnJFOmZ1bmN0aW9uKGEsYixjLGQpe3Zh
-ciBzPVcuQzAoVy5DMChXLkMwKFcuQzAoMCxhKSxiKSxjKSxkKSxyPXMrKChzJjY3MTA4ODYzKTw8Mykm
-NTM2ODcwOTExCnJePXI+Pj4xMQpyZXR1cm4gcisoKHImMTYzODMpPDwxNSkmNTM2ODcwOTExfSwKVE46
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9YS5jbGFzc0xpc3QKZm9yKHM9Yi5sZW5ndGgscj0wO3I8Yi5s
-ZW5ndGg7Yi5sZW5ndGg9PT1zfHwoMCxILmxrKShiKSwrK3IpcS5hZGQoYltyXSl9LApKRTpmdW5jdGlv
-bihhLGIsYyxkLGUpe3ZhciBzPVcuYUYobmV3IFcudk4oYyksdC5CKQppZihzIT1udWxsJiYhMClKLmRa
-KGEsYixzLCExKQpyZXR1cm4gbmV3IFcueEMoYSxiLHMsITEsZS5DKCJ4QzwwPiIpKX0sClR3OmZ1bmN0
-aW9uKGEpe3ZhciBzPVcuSjYobnVsbCkscj13aW5kb3cubG9jYXRpb24Kcz1uZXcgVy5KUShuZXcgVy5t
-ayhzLHIpKQpzLkNZKGEpCnJldHVybiBzfSwKcUQ6ZnVuY3Rpb24oYSxiLGMsZCl7dC5oLmEoYSkKSC5o
-KGIpCkguaChjKQp0LmNyLmEoZCkKcmV0dXJuITB9LApuWjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxy
-LHEKdC5oLmEoYSkKSC5oKGIpCkguaChjKQpzPXQuY3IuYShkKS5hCnI9cy5hCkMueG4uc0xVKHIsYykK
-cT1yLmhvc3RuYW1lCnM9cy5iCmlmKCEocT09cy5ob3N0bmFtZSYmci5wb3J0PT1zLnBvcnQmJnIucHJv
-dG9jb2w9PXMucHJvdG9jb2wpKWlmKHE9PT0iIilpZihyLnBvcnQ9PT0iIil7cz1yLnByb3RvY29sCnM9
-cz09PSI6Inx8cz09PSIifWVsc2Ugcz0hMQplbHNlIHM9ITEKZWxzZSBzPSEwCnJldHVybiBzfSwKQmw6
-ZnVuY3Rpb24oKXt2YXIgcz10Lk4scj1QLnRNKEMuUXgscykscT10LmQwLmEobmV3IFcuSUEoKSkscD1I
-LlZNKFsiVEVNUExBVEUiXSx0LnMpCnM9bmV3IFcuY3QocixQLkxzKHMpLFAuTHMocyksUC5McyhzKSxu
-dWxsKQpzLkNZKG51bGwsbmV3IEgubEooQy5ReCxxLHQuZmopLHAsbnVsbCkKcmV0dXJuIHN9LApxYzpm
-dW5jdGlvbihhKXt2YXIgcwppZihhPT1udWxsKXJldHVybiBudWxsCmlmKCJwb3N0TWVzc2FnZSIgaW4g
-YSl7cz1XLlAxKGEpCmlmKHQuYVMuYihzKSlyZXR1cm4gcwpyZXR1cm4gbnVsbH1lbHNlIHJldHVybiB0
-LmNoLmEoYSl9LApQMTpmdW5jdGlvbihhKXtpZihhPT09d2luZG93KXJldHVybiB0LmNpLmEoYSkKZWxz
-ZSByZXR1cm4gbmV3IFcuZFcoKX0sCmFGOmZ1bmN0aW9uKGEsYil7dmFyIHM9JC5YMwppZihzPT09Qy5O
-VSlyZXR1cm4gYQpyZXR1cm4gcy5QeShhLGIpfSwKcUU6ZnVuY3Rpb24gcUUoKXt9LApHaDpmdW5jdGlv
-biBHaCgpe30sCmZZOmZ1bmN0aW9uIGZZKCl7fSwKbkI6ZnVuY3Rpb24gbkIoKXt9LApBejpmdW5jdGlv
-biBBeigpe30sClFQOmZ1bmN0aW9uIFFQKCl7fSwKbng6ZnVuY3Rpb24gbngoKXt9LApvSjpmdW5jdGlv
-biBvSigpe30sCmlkOmZ1bmN0aW9uIGlkKCl7fSwKUUY6ZnVuY3Rpb24gUUYoKXt9LApOaDpmdW5jdGlv
-biBOaCgpe30sCmFlOmZ1bmN0aW9uIGFlKCl7fSwKSUI6ZnVuY3Rpb24gSUIoKXt9LApuNzpmdW5jdGlv
-biBuNygpe30sCnd6OmZ1bmN0aW9uIHd6KGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sCmN2OmZ1bmN0
-aW9uIGN2KCl7fSwKQ3Y6ZnVuY3Rpb24gQ3YoKXt9LAplYTpmdW5jdGlvbiBlYSgpe30sCkQwOmZ1bmN0
-aW9uIEQwKCl7fSwKaEg6ZnVuY3Rpb24gaEgoKXt9LApoNDpmdW5jdGlvbiBoNCgpe30sCmJyOmZ1bmN0
-aW9uIGJyKCl7fSwKVmI6ZnVuY3Rpb24gVmIoKXt9LApmSjpmdW5jdGlvbiBmSigpe30sCndhOmZ1bmN0
-aW9uIHdhKCl7fSwKU2c6ZnVuY3Rpb24gU2coKXt9LAp3NzpmdW5jdGlvbiB3Nygpe30sCkFqOmZ1bmN0
-aW9uIEFqKCl7fSwKZTc6ZnVuY3Rpb24gZTcoYSl7dGhpcy5hPWF9LAp1SDpmdW5jdGlvbiB1SCgpe30s
-CkJIOmZ1bmN0aW9uIEJIKCl7fSwKU046ZnVuY3Rpb24gU04oKXt9LApldzpmdW5jdGlvbiBldygpe30s
-CmxwOmZ1bmN0aW9uIGxwKCl7fSwKVGI6ZnVuY3Rpb24gVGIoKXt9LApJdjpmdW5jdGlvbiBJdigpe30s
-CldQOmZ1bmN0aW9uIFdQKCl7fSwKeVk6ZnVuY3Rpb24geVkoKXt9LAp3NjpmdW5jdGlvbiB3Nigpe30s
-Cks1OmZ1bmN0aW9uIEs1KCl7fSwKQ206ZnVuY3Rpb24gQ20oKXt9LApDUTpmdW5jdGlvbiBDUSgpe30s
-Cnc0OmZ1bmN0aW9uIHc0KCl7fSwKcmg6ZnVuY3Rpb24gcmgoKXt9LApjZjpmdW5jdGlvbiBjZigpe30s
-Cmk3OmZ1bmN0aW9uIGk3KGEpe3RoaXMuYT1hfSwKU3k6ZnVuY3Rpb24gU3koYSl7dGhpcy5hPWF9LApL
-UzpmdW5jdGlvbiBLUyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKQTM6ZnVuY3Rpb24gQTMoYSxiKXt0
-aGlzLmE9YQp0aGlzLmI9Yn0sCkk0OmZ1bmN0aW9uIEk0KGEpe3RoaXMuYT1hfSwKRms6ZnVuY3Rpb24g
-RmsoYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKUk86ZnVuY3Rpb24gUk8oYSxiLGMsZCl7dmFyIF89
-dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLiR0aT1kfSwKZXU6ZnVuY3Rpb24gZXUoYSxiLGMsZCl7dmFy
-IF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLiR0aT1kfSwKeEM6ZnVuY3Rpb24geEMoYSxiLGMsZCxl
-KXt2YXIgXz10aGlzCl8uYj1hCl8uYz1iCl8uZD1jCl8uZT1kCl8uJHRpPWV9LAp2TjpmdW5jdGlvbiB2
-TihhKXt0aGlzLmE9YX0sCkpROmZ1bmN0aW9uIEpRKGEpe3RoaXMuYT1hfSwKR206ZnVuY3Rpb24gR20o
-KXt9LAp2RDpmdW5jdGlvbiB2RChhKXt0aGlzLmE9YX0sClV2OmZ1bmN0aW9uIFV2KGEpe3RoaXMuYT1h
-fSwKRWc6ZnVuY3Rpb24gRWcoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKbTY6ZnVu
-Y3Rpb24gbTYoKXt9LApFbzpmdW5jdGlvbiBFbygpe30sCldrOmZ1bmN0aW9uIFdrKCl7fSwKY3Q6ZnVu
-Y3Rpb24gY3QoYSxiLGMsZCxlKXt2YXIgXz10aGlzCl8uZT1hCl8uYT1iCl8uYj1jCl8uYz1kCl8uZD1l
-fSwKSUE6ZnVuY3Rpb24gSUEoKXt9LApPdzpmdW5jdGlvbiBPdygpe30sClc5OmZ1bmN0aW9uIFc5KGEs
-YixjKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz0tMQpfLmQ9bnVsbApfLiR0aT1jfSwKZFc6ZnVu
-Y3Rpb24gZFcoKXt9LAptazpmdW5jdGlvbiBtayhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKS286ZnVu
-Y3Rpb24gS28oYSl7dGhpcy5hPWEKdGhpcy5iPSExfSwKZm06ZnVuY3Rpb24gZm0oYSl7dGhpcy5hPWF9
-LApMZTpmdW5jdGlvbiBMZSgpe30sCks3OmZ1bmN0aW9uIEs3KCl7fSwKckI6ZnVuY3Rpb24gckIoKXt9
-LApYVzpmdW5jdGlvbiBYVygpe30sCm9hOmZ1bmN0aW9uIG9hKCl7fX0sVT17CmpmOmZ1bmN0aW9uKGEp
-e3ZhciBzLHIscSxwCmlmKGE9PW51bGwpcz1udWxsCmVsc2V7cz1ILlZNKFtdLHQuZDcpCmZvcihyPUou
-SVQodC5VLmEoYSkpO3IuRigpOyl7cT1yLmdsKCkKcD1KLlU2KHEpCnMucHVzaChuZXcgVS5TZShILmgo
-cC5xKHEsImRlc2NyaXB0aW9uIikpLEguaChwLnEocSwiaHJlZiIpKSkpfX1yZXR1cm4gc30sCk5kOmZ1
-bmN0aW9uKGEpe3ZhciBzLHIKaWYoYT09bnVsbClzPW51bGwKZWxzZXtzPUguVk0oW10sdC5hQSkKZm9y
-KHI9Si5JVCh0LlUuYShhKSk7ci5GKCk7KXMucHVzaChVLk5mKHIuZ2woKSkpfXJldHVybiBzfSwKTmY6
-ZnVuY3Rpb24oYSl7dmFyIHM9Si5VNihhKSxyPUguaChzLnEoYSwiZGVzY3JpcHRpb24iKSkscT1ILlZN
-KFtdLHQuYUopCmZvcihzPUouSVQodC5VLmEocy5xKGEsImVudHJpZXMiKSkpO3MuRigpOylxLnB1c2go
-VS5SaihzLmdsKCkpKQpyZXR1cm4gbmV3IFUueUQocixxKX0sClJqOmZ1bmN0aW9uKGEpe3ZhciBzLHI9
-Si5VNihhKSxxPUguaChyLnEoYSwiZGVzY3JpcHRpb24iKSkscD1ILmgoci5xKGEsImZ1bmN0aW9uIikp
-LG89ci5xKGEsImxpbmsiKQppZihvPT1udWxsKW89bnVsbAplbHNle3M9Si5VNihvKQpvPW5ldyBVLk1s
-KEguaChzLnEobywiaHJlZiIpKSxILnVQKHMucShvLCJsaW5lIikpLEguaChzLnEobywicGF0aCIpKSl9
-cj10LmZLLmEoci5xKGEsImhpbnRBY3Rpb25zIikpCnI9cj09bnVsbD9udWxsOkouTTEocixuZXcgVS5h
-TigpLHQuYVgpCnI9cj09bnVsbD9udWxsOnIuYnIoMCkKcmV0dXJuIG5ldyBVLndiKHEscCxvLHI9PW51
-bGw/Qy5kbjpyKX0sCmQyOmZ1bmN0aW9uIGQyKGEsYixjLGQsZSxmKXt2YXIgXz10aGlzCl8uYT1hCl8u
-Yj1iCl8uYz1jCl8uZD1kCl8uZT1lCl8uZj1mfSwKU2U6ZnVuY3Rpb24gU2UoYSxiKXt0aGlzLmE9YQp0
-aGlzLmI9Yn0sCk1sOmZ1bmN0aW9uIE1sKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30s
-CnlEOmZ1bmN0aW9uIHlEKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LAp3YjpmdW5jdGlvbiB3YihhLGIs
-YyxkKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kfSwKYU46ZnVuY3Rpb24gYU4oKXt9
-LApiMDpmdW5jdGlvbiBiMCgpe319LEI9ewp3UjpmdW5jdGlvbigpe3JldHVybiBuZXcgQi5xcCgiIiwi
-IiwiIixDLkR4KX0sCllmOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsaz1ILmgoYS5xKDAs
-InJlZ2lvbnMiKSksaj1ILmgoYS5xKDAsIm5hdmlnYXRpb25Db250ZW50IikpLGk9SC5oKGEucSgwLCJz
-b3VyY2VDb2RlIikpLGg9UC5GbCh0LlgsdC5kXykKZm9yKHM9dC50LmEoYS5xKDAsImVkaXRzIikpLHM9
-cy5nUHUocykscz1zLmdtKHMpLHI9dC5VLHE9dC5oNDtzLkYoKTspe3A9cy5nbCgpCm89cC5hCm49SC5W
-TShbXSxxKQpmb3IocD1KLklUKHIuYShwLmIpKTtwLkYoKTspe209cC5nbCgpCmw9Si5VNihtKQpuLnB1
-c2gobmV3IEIuajgoSC51UChsLnEobSwibGluZSIpKSxILmgobC5xKG0sImV4cGxhbmF0aW9uIikpLEgu
-dVAobC5xKG0sIm9mZnNldCIpKSkpfWguWTUoMCxvLG4pfXJldHVybiBuZXcgQi5xcChrLGosaSxoKX0s
-Cmo4OmZ1bmN0aW9uIGo4KGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCnFwOmZ1bmN0
-aW9uIHFwKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWR9LApmdjpmdW5j
-dGlvbiBmdigpe30sCk9TOmZ1bmN0aW9uKGEpe3ZhciBzCmlmKCEoYT49NjUmJmE8PTkwKSlzPWE+PTk3
-JiZhPD0xMjIKZWxzZSBzPSEwCnJldHVybiBzfSwKWXU6ZnVuY3Rpb24oYSxiKXt2YXIgcz1hLmxlbmd0
-aCxyPWIrMgppZihzPHIpcmV0dXJuITEKaWYoIUIuT1MoQy54Qi5PKGEsYikpKXJldHVybiExCmlmKEMu
-eEIuTyhhLGIrMSkhPT01OClyZXR1cm4hMQppZihzPT09cilyZXR1cm4hMApyZXR1cm4gQy54Qi5PKGEs
-cik9PT00N319LFQ9e21ROmZ1bmN0aW9uIG1RKCl7fX0sTD17CklxOmZ1bmN0aW9uKCl7Qy5CWi5CKGRv
-Y3VtZW50LCJET01Db250ZW50TG9hZGVkIixuZXcgTC5lKCkpCkMub2wuQih3aW5kb3csInBvcHN0YXRl
-IixuZXcgTC5MKCkpfSwKa3o6ZnVuY3Rpb24oYSl7dmFyIHMscj10LmcuYShhLnBhcmVudE5vZGUpLnF1
-ZXJ5U2VsZWN0b3IoIjpzY29wZSA+IHVsIikscT1yLnN0eWxlLHA9IiIrQy5DRC56UShyLm9mZnNldEhl
-aWdodCkqMisicHgiCnEubWF4SGVpZ2h0PXAKcT1KLnFGKGEpCnA9cS4kdGkKcz1wLkMoIn4oMSk/Iiku
-YShuZXcgTC5XeChyLGEpKQp0LlouYShudWxsKQpXLkpFKHEuYSxxLmIscywhMSxwLmMpfSwKeVg6ZnVu
-Y3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbT0icXVlcnlTZWxlY3RvckFsbCIsbD1kb2N1bWVudC5x
-dWVyeVNlbGVjdG9yKGEpLGs9dC5nCmwudG9TdHJpbmcKcz10LmgKSC5EaChrLHMsIlQiLG0pCnI9dC5S
-CnE9bmV3IFcud3oobC5xdWVyeVNlbGVjdG9yQWxsKCIubmF2LWxpbmsiKSxyKQpxLksocSxuZXcgTC5B
-TyhiKSkKSC5EaChrLHMsIlQiLG0pCnA9bmV3IFcud3oobC5xdWVyeVNlbGVjdG9yQWxsKCIucmVnaW9u
-IikscikKaWYoIXAuZ2wwKHApKXtvPWwucXVlcnlTZWxlY3RvcigidGFibGVbZGF0YS1wYXRoXSIpCm8u
-dG9TdHJpbmcKcC5LKHAsbmV3IEwuSG8oby5nZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcg
-Vy5pNyhvKSkuT1UoInBhdGgiKSkpKX1ILkRoKGsscywiVCIsbSkKbj1uZXcgVy53eihsLnF1ZXJ5U2Vs
-ZWN0b3JBbGwoIi5hZGQtaGludC1saW5rIikscikKbi5LKG4sbmV3IEwuSUMoKSl9LApRNjpmdW5jdGlv
-bihhLGIsYyl7dmFyIHM9bmV3IFhNTEh0dHBSZXF1ZXN0KCkKQy5EdC5lbyhzLCJHRVQiLEwuUTQoYSxi
-KSwhMCkKcy5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9qc29uOyBj
-aGFyc2V0PVVURi04IikKcmV0dXJuIEwuTFUocyxudWxsLGMuQygiMCoiKSl9LAp0eTpmdW5jdGlvbihh
-LGIpe3ZhciBzPW5ldyBYTUxIdHRwUmVxdWVzdCgpLHI9dC5YCkMuRHQuZW8ocywiUE9TVCIsTC5RNChh
-LFAuRmwocixyKSksITApCnMuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC1UeXBlIiwiYXBwbGljYXRp
-b24vanNvbjsgY2hhcnNldD1VVEYtOCIpCnJldHVybiBMLkxVKHMsYix0LnQpfSwKTFU6ZnVuY3Rpb24o
-YSxiLGMpe3JldHVybiBMLlRnKGEsYixjLGMuQygiMCoiKSl9LApUZzpmdW5jdGlvbihhLGIsYyxkKXt2
-YXIgcz0wLHI9UC5GWChkKSxxLHA9MixvLG49W10sbSxsLGssaixpLGgsZyxmLGUKdmFyICRhc3luYyRM
-VT1QLmx6KGZ1bmN0aW9uKGEwLGExKXtpZihhMD09PTEpe289YTEKcz1wfXdoaWxlKHRydWUpc3dpdGNo
-KHMpe2Nhc2UgMDpoPW5ldyBQLlpmKG5ldyBQLnZzKCQuWDMsdC5nViksdC5iQykKZz10LmViCmY9Zy5h
-KG5ldyBMLmZDKGgsYSkpCnQuWi5hKG51bGwpCms9dC5lUQpXLkpFKGEsImxvYWQiLGYsITEsaykKVy5K
-RShhLCJlcnJvciIsZy5hKGguZ1lKKCkpLCExLGspCmEuc2VuZChiPT1udWxsP251bGw6Qy5DdC5PQihi
-LG51bGwpKQpwPTQKcz03CnJldHVybiBQLmpRKGguYSwkYXN5bmMkTFUpCmNhc2UgNzpwPTIKcz02CmJy
-ZWFrCmNhc2UgNDpwPTMKZT1vCkguUnUoZSkKbT1ILnRzKGUpCmc9YS5yZWFkeVN0YXRlCmlmKGc9PT00
-JiZhLnN0YXR1cz09PTApdGhyb3cgSC5iKEwuVEcoIkVycm9yIHJlYWNoaW5nIG1pZ3JhdGlvbiBwcmV2
-aWV3IHNlcnZlciIsIlRoaXMgdXN1YWxseSBoYXBwZW5zIGJlY2F1c2UgdGhlIG1pZ3JhdGlvbiBwcmV2
-aWV3IHNlcnZlciBoYXMgZXhpdGVkLiAgRm9yXG5leGFtcGxlIGl0IG1heSBoYXZlIGJlZW4gYWJvcnRl
-ZCB3aXRoIEN0cmwtQywgb3IgeW91IG1heSBoYXZlIGNvbXBsZXRlZCB0aGlzXG5taWdyYXRpb24sIG9y
-IGFuIGV4Y2VwdGlvbiBtYXkgaGF2ZSBvY2N1cnJlZC4gIFBsZWFzZSBjaGVjayB0aGUgY29uc29sZSB3
-aGVyZVxueW91IGludm9rZWQgYGRhcnQgbWlncmF0ZWAgdG8gdmVyaWZ5IHRoYXQgdGhlIHByZXZpZXcg
-c2VydmVyIGlzIHN0aWxsIHJ1bm5pbmcuXG4iKSkKZWxzZXtsPW5ldyBILmxKKEguVk0oWyJyZWFkeVN0
-YXRlPSIrSC5FaihnKSwicmVzcG9uc2VUZXh0PSIrQy5DdC5PQihhLnJlc3BvbnNlVGV4dCxudWxsKSwi
-cmVzcG9uc2VUeXBlPSIrQy5DdC5PQihhLnJlc3BvbnNlVHlwZSxudWxsKSwicmVzcG9uc2VVcmw9IitD
-LkN0Lk9CKGEucmVzcG9uc2VVUkwsbnVsbCksInN0YXR1cz0iK0guRWooYS5zdGF0dXMpLCJzdGF0dXNU
-ZXh0PSIrQy5DdC5PQihhLnN0YXR1c1RleHQsbnVsbCldLHQuaSksdC5lcS5hKG5ldyBMLlRtKCkpLHQu
-ZlApLmsoMCwiLCAiKQp0aHJvdyBILmIoUC5UbCgiRXJyb3IgcmVhY2hpbmcgbWlncmF0aW9uIHByZXZp
-ZXcgc2VydmVyOiAiK0guRWoobCksbSkpfXM9NgpicmVhawpjYXNlIDM6cz0yCmJyZWFrCmNhc2UgNjpp
-ZihhLnN0YXR1cz09PTQwMSl0aHJvdyBILmIoTC5URygiVW5hdXRob3JpemVkIHJlc3BvbnNlIGZyb20g
-bWlncmF0aW9uIHByZXZpZXcgc2VydmVyIiwiVGhlIG1pZ3JhdGlvbiBwcmV2aWV3IHNlcnZlciBoYXMg
-ZGV0ZWN0ZWQgYSBtaXNtYXRjaCBiZXR3ZWVuIHRoZSBhdXRoVG9rZW4gaW5cbnlvdXIgVVJMIGFuZCB0
-aGUgdG9rZW4gdGhhdCB3YXMgZ2VuZXJhdGVkIGF0IHRoZSB0aW1lIHRoYXQgYGRhcnQgbWlncmF0ZWAg
-d2FzXG5ydW4uICBIYXZlIHlvdSByZXN0YXJ0ZWQgdGhlIG1pZ3JhdGlvbiBzZXJ2ZXIgcmVjZW50bHk/
-ICBJZiBzbywgeW91J2xsIG5lZWQgdG9cbmNoZWNrIGl0cyBvdXRwdXQgZm9yIGEgZnJlc2ggVVJMLCBh
-bmQgdXNlIHRoYXQgVVJMIHRvIHBlcmZvcm0geW91ciBtaWdyYXRpb24uXG4iKSkKaT1DLkN0LnBXKDAs
-YS5yZXNwb25zZVRleHQsbnVsbCkKaWYoYS5zdGF0dXM9PT0yMDApe3E9Yy5DKCIwKiIpLmEoaSkKcz0x
-CmJyZWFrfWVsc2UgdGhyb3cgSC5iKGkpCmNhc2UgMTpyZXR1cm4gUC55QyhxLHIpCmNhc2UgMjpyZXR1
-cm4gUC5mMyhvLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRMVSxyKX0sCmFLOmZ1bmN0aW9uKGEpe3Zh
-ciBzPVAuaEsoYSkuZ2hZKCkucSgwLCJsaW5lIikKcmV0dXJuIHM9PW51bGw/bnVsbDpILkhwKHMsbnVs
-bCl9LApHNjpmdW5jdGlvbihhKXt2YXIgcz1QLmhLKGEpLmdoWSgpLnEoMCwib2Zmc2V0IikKcmV0dXJu
-IHM9PW51bGw/bnVsbDpILkhwKHMsbnVsbCl9LAppNjpmdW5jdGlvbihhKXtyZXR1cm4gTC5uVyh0Lk8u
-YShhKSl9LApuVzpmdW5jdGlvbihhKXt2YXIgcz0wLHI9UC5GWCh0LnopLHE9MSxwLG89W10sbixtLGws
-ayxqLGksaAp2YXIgJGFzeW5jJGk2PVAubHooZnVuY3Rpb24oYixjKXtpZihiPT09MSl7cD1jCnM9cX13
-aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6aT10LmcuYShXLnFjKGEuY3VycmVudFRhcmdldCkpLmdl
-dEF0dHJpYnV0ZSgiaHJlZiIpCmEucHJldmVudERlZmF1bHQoKQpxPTMKaz1kb2N1bWVudApuPUMuQ0Qu
-elEoay5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkKcz02CnJldHVybiBQLmpRKEwu
-dHkoaSxudWxsKSwkYXN5bmMkaTYpCmNhc2UgNjpzPTcKcmV0dXJuIFAualEoTC5HNyh3aW5kb3cubG9j
-YXRpb24ucGF0aG5hbWUsbnVsbCxudWxsLCExLG51bGwpLCRhc3luYyRpNikKY2FzZSA3OmsuYm9keS5j
-bGFzc0xpc3QuYWRkKCJuZWVkcy1yZXJ1biIpCms9ay5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpCmsu
-dG9TdHJpbmcKay5zY3JvbGxUb3A9Si5WdShuKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKaD1wCm09
-SC5SdShoKQpsPUgudHMoaCkKTC5DMigiY291bGRuJ3QgYWRkL3JlbW92ZSBoaW50IixtLGwpCnM9NQpi
-cmVhawpjYXNlIDI6cz0xCmJyZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIpCmNhc2UgMTpyZXR1
-cm4gUC5mMyhwLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRpNixyKX0sCkMyOmZ1bmN0aW9uKGEsYixj
-KXt2YXIgcyxyLHEscCxvLG49ImV4Y2VwdGlvbiIsbT0ic3RhY2tUcmFjZSIKaWYodC50LmIoYikmJkou
-Uk0oYi5xKDAsInN1Y2Nlc3MiKSwhMSkmJmIueDQobikmJmIueDQobSkpe3M9Si5VNihiKQpyPUguaChz
-LnEoYixuKSkKYz1zLnEoYixtKQpxPW51bGx9ZWxzZSBpZihiIGluc3RhbmNlb2YgTC5RVyl7cj1iLmEK
-cT1iLmJ9ZWxzZXtyPUouaihiKQpxPW51bGx9aWYocT09bnVsbClxPWMKcz1kb2N1bWVudApwPXMucXVl
-cnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKQpwLnF1ZXJ5U2VsZWN0b3IoImgyIikuaW5uZXJUZXh0PWEK
-cC5xdWVyeVNlbGVjdG9yKCJwIikuaW5uZXJUZXh0PXIKcC5xdWVyeVNlbGVjdG9yKCJwcmUiKS5pbm5l
-clRleHQ9Si5qKHEpCm89dC5kZC5hKHAucXVlcnlTZWxlY3RvcigiYS5ib3R0b20iKSk7KG8mJkMueG4p
-LnNMVShvLFAuWGQoImh0dHBzIiwiZ2l0aHViLmNvbSIsImRhcnQtbGFuZy9zZGsvaXNzdWVzL25ldyIs
-UC5FRihbInRpdGxlIiwiQ3VzdG9tZXItcmVwb3J0ZWQgaXNzdWUgd2l0aCBOTkJEIG1pZ3JhdGlvbiB0
-b29sOiAiK2EsImxhYmVscyIsdS5kLCJib2R5IixhKyJcblxuRXJyb3I6ICIrSC5FaihyKSsiXG5cblBs
-ZWFzZSBmaWxsIGluIHRoZSBmb2xsb3dpbmc6XG5cbioqTmFtZSBvZiBwYWNrYWdlIGJlaW5nIG1pZ3Jh
-dGVkIChpZiBwdWJsaWMpKio6XG4qKldoYXQgSSB3YXMgZG9pbmcgd2hlbiB0aGlzIGlzc3VlIG9jY3Vy
-cmVkKio6XG4qKklzIGl0IHBvc3NpYmxlIHRvIHdvcmsgYXJvdW5kIHRoaXMgaXNzdWUqKjpcbioqSGFz
-IHRoaXMgaXNzdWUgaGFwcGVuZWQgYmVmb3JlLCBhbmQgaWYgc28sIGhvdyBvZnRlbioqOlxuKipEYXJ0
-IFNESyB2ZXJzaW9uKio6ICIrSC5FaihzLmdldEVsZW1lbnRCeUlkKCJzZGstdmVyc2lvbiIpLnRleHRD
-b250ZW50KSsiXG4qKkFkZGl0aW9uYWwgZGV0YWlscyoqOlxuXG5UaGFua3MgZm9yIGZpbGluZyFcblxu
-U3RhY2t0cmFjZTogX2F1dG8gcG9wdWxhdGVkIGJ5IG1pZ3JhdGlvbiBwcmV2aWV3IHRvb2wuX1xuXG5g
-YGBcbiIrSC5FaihjKSsiXG5gYGBcbiJdLHQuWCx0LnopKS5nbkQoKSkKcz1vLnN0eWxlCnMuZGlzcGxh
-eT0iaW5pdGlhbCIKcz1wLnN0eWxlCnMuZGlzcGxheT0iaW5pdGlhbCIKcz1hKyI6ICIrSC5FaihiKQp3
-aW5kb3cKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLmVycm9yKHMp
-CndpbmRvdwpzPUguRWooYykKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25z
-b2xlLmVycm9yKHMpfSwKdDI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvPXQuZy5hKFcucWMoYS5j
-dXJyZW50VGFyZ2V0KSkKYS5wcmV2ZW50RGVmYXVsdCgpCnM9by5nZXRBdHRyaWJ1dGUoImhyZWYiKQpy
-PUwuVXMocykKcT1MLkc2KHMpCnA9TC5hSyhzKQppZihxIT1udWxsKUwuYWYocixxLHAsYixuZXcgTC5u
-VChyLHEscCkpCmVsc2UgTC5hZihyLG51bGwsbnVsbCxiLG5ldyBMLk5ZKHIpKX0sCkswOmZ1bmN0aW9u
-KGEpe3ZhciBzLHIscSxwPWRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIi5wb3B1cC1wYW5lIikKcC5xdWVy
-eVNlbGVjdG9yKCJoMiIpLmlubmVyVGV4dD0iRmFpbGVkIHRvIHJlcnVuIGZyb20gc291cmNlcyIKcC5x
-dWVyeVNlbGVjdG9yKCJwIikuaW5uZXJUZXh0PSJTb3VyY2VzIGNvbnRhaW4gc3RhdGljIGFuYWx5c2lz
-IGVycm9yczoiCnM9cC5xdWVyeVNlbGVjdG9yKCJwcmUiKQpyPUouRWwoYSx0LmF3KQpxPUguTGgocikK
-cy5pbm5lclRleHQ9bmV3IEgubEoocixxLkMoInFVKihsRC5FKSIpLmEobmV3IEwudWUoKSkscS5DKCJs
-SjxsRC5FLHFVKj4iKSkuaygwLCJcbiIpCnE9cC5xdWVyeVNlbGVjdG9yKCJhLmJvdHRvbSIpLnN0eWxl
-CnEuZGlzcGxheT0ibm9uZSIKcz1wLnN0eWxlCnMuZGlzcGxheT0iaW5pdGlhbCJ9LAp2VTpmdW5jdGlv
-bigpe3ZhciBzPWRvY3VtZW50CkguRGgodC5nLHQuaCwiVCIsInF1ZXJ5U2VsZWN0b3JBbGwiKQpzPW5l
-dyBXLnd6KHMucXVlcnlTZWxlY3RvckFsbCgiLmNvZGUiKSx0LlIpCnMuSyhzLG5ldyBMLmVYKCkpfSwK
-aFg6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBMLll3KGEsYixjKX0sCll3OmZ1bmN0aW9uKGEsYixjKXt2
-YXIgcz0wLHI9UC5GWCh0LnopLHE9MSxwLG89W10sbixtLGwsayxqLGksaCxnCnZhciAkYXN5bmMkaFg9
-UC5seihmdW5jdGlvbihkLGUpe2lmKGQ9PT0xKXtwPWUKcz1xfXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nh
-c2UgMDpxPTMKaj10LlgKcz02CnJldHVybiBQLmpRKEwuUTYoYSxQLkVGKFsicmVnaW9uIiwicmVnaW9u
-Iiwib2Zmc2V0IixILkVqKGIpXSxqLGopLHQudCksJGFzeW5jJGhYKQpjYXNlIDY6bj1lCmo9bgppPUou
-VTYoaikKbT1uZXcgVS5kMihVLmpmKGkucShqLCJlZGl0cyIpKSxILmgoaS5xKGosImV4cGxhbmF0aW9u
-IikpLEgudVAoaS5xKGosImxpbmUiKSksSC5oKGkucShqLCJkaXNwbGF5UGF0aCIpKSxILmgoaS5xKGos
-InVyaVBhdGgiKSksVS5OZChpLnEoaiwidHJhY2VzIikpKQpMLlQxKG0pCkwuRnIoYSxiLGMpCkwueVgo
-Ii5lZGl0LXBhbmVsIC5wYW5lbC1jb250ZW50IiwhMSkKcT0xCnM9NQpicmVhawpjYXNlIDM6cT0yCmc9
-cApsPUguUnUoZykKaz1ILnRzKGcpCkwuQzIoImNvdWxkbid0IGxvYWQgZWRpdCBkZXRhaWxzIixsLGsp
-CnM9NQpicmVhawpjYXNlIDI6cz0xCmJyZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIpCmNhc2Ug
-MTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRoWCxyKX0sCkc3OmZ1bmN0aW9u
-KGEsYixjLGQsZSl7cmV0dXJuIEwuTDUoYSxiLGMsZCxlKX0sCkw1OmZ1bmN0aW9uKGEsYixjLGQsZSl7
-dmFyIHM9MCxyPVAuRlgodC5IKSxxLHA9MixvLG49W10sbSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJEc3
-PVAubHooZnVuY3Rpb24oZixhMCl7aWYoZj09PTEpe289YTAKcz1wfXdoaWxlKHRydWUpc3dpdGNoKHMp
-e2Nhc2UgMDppZighSi5wNChhLCIuZGFydCIpKXtMLkJFKGEsQi53UigpLGQpCkwuQlgoYSxudWxsKQpp
-ZihlIT1udWxsKWUuJDAoKQpzPTEKYnJlYWt9cD00Cmk9dC5YCnM9NwpyZXR1cm4gUC5qUShMLlE2KGEs
-UC5FRihbImlubGluZSIsInRydWUiXSxpLGkpLHQudCksJGFzeW5jJEc3KQpjYXNlIDc6bT1hMApMLkJF
-KGEsQi5ZZihtKSxkKQpMLmZHKGIsYykKbD1MLlVzKGEpCkwuQlgobCxiKQppZihlIT1udWxsKWUuJDAo
-KQpwPTIKcz02CmJyZWFrCmNhc2UgNDpwPTMKZz1vCms9SC5SdShnKQpqPUgudHMoZykKTC5DMigiY291
-bGRuJ3QgbG9hZCBkYXJ0IGZpbGUgIithLGssaikKcz02CmJyZWFrCmNhc2UgMzpzPTIKYnJlYWsKY2Fz
-ZSA2OmNhc2UgMTpyZXR1cm4gUC55QyhxLHIpCmNhc2UgMjpyZXR1cm4gUC5mMyhvLHIpfX0pCnJldHVy
-biBQLkRJKCRhc3luYyRHNyxyKX0sCkdlOmZ1bmN0aW9uKCl7dmFyIHM9MCxyPVAuRlgodC56KSxxPTEs
-cCxvPVtdLG4sbSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJEdlPVAubHooZnVuY3Rpb24oYSxiKXtpZihh
-PT09MSl7cD1iCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6aD0iL19wcmV2aWV3L25hdmln
-YXRpb25UcmVlLmpzb24iCnE9MwpzPTYKcmV0dXJuIFAualEoTC5RNihoLEMuQ00sdC5lRSksJGFzeW5j
-JEdlKQpjYXNlIDY6bj1iCm09ZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLm5hdi10cmVlIikKSi5sNSht
-LCIiKQpqPUwubUsobikKJC5JUj1qCkwudFgobSxqLCEwKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIK
-Zz1wCmw9SC5SdShnKQprPUgudHMoZykKTC5DMigiY291bGRuJ3QgbG9hZCBuYXZpZ2F0aW9uIHRyZWUi
-LGwsaykKcz01CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikK
-Y2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJEdlLHIpfSwKcU86ZnVu
-Y3Rpb24oYSl7dmFyIHMscj1hLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLHE9Qy5DRC56USgkLmZpKCku
-b2Zmc2V0SGVpZ2h0KSxwPXdpbmRvdy5pbm5lckhlaWdodCxvPUMuQ0QuelEoJC5EVygpLm9mZnNldEhl
-aWdodCkKaWYodHlwZW9mIHAhPT0ibnVtYmVyIilyZXR1cm4gcC5ITigpCnM9ci5ib3R0b20Kcy50b1N0
-cmluZwppZihzPnAtKG8rMTQpKUouZGgoYSkKZWxzZXtwPXIudG9wCnAudG9TdHJpbmcKaWYocDxxKzE0
-KUouZGgoYSl9fSwKZkc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCmlmKGEhPW51bGwpe3M9ZG9j
-dW1lbnQKcj1zLmdldEVsZW1lbnRCeUlkKCJvIitILkVqKGEpKQpxPXMucXVlcnlTZWxlY3RvcigiLmxp
-bmUtIitILkVqKGIpKQppZihyIT1udWxsKXtMLnFPKHIpCkouZFIocikuaSgwLCJ0YXJnZXQiKX1lbHNl
-IGlmKHEhPW51bGwpTC5xTyhxLnBhcmVudEVsZW1lbnQpCmlmKHEhPW51bGwpSi5kUih0LmcuYShxLnBh
-cmVudE5vZGUpKS5pKDAsImhpZ2hsaWdodCIpfWVsc2V7cz1kb2N1bWVudApwPXQuZwpILkRoKHAsdC5o
-LCJUIiwicXVlcnlTZWxlY3RvckFsbCIpCnM9cy5xdWVyeVNlbGVjdG9yQWxsKCIubGluZS1ubyIpCm89
-bmV3IFcud3oocyx0LlIpCmlmKG8uZ0Eobyk9PT0wKXJldHVybgpMLnFPKHAuYShDLnQ1Lmd0SChzKSkp
-fX0sCmFmOmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHMscixxPUwuRzYod2luZG93LmxvY2F0aW9uLmhy
-ZWYpLHA9TC5hSyh3aW5kb3cubG9jYXRpb24uaHJlZikKaWYocSE9bnVsbCl7cz1kb2N1bWVudC5nZXRF
-bGVtZW50QnlJZCgibyIrSC5FaihxKSkKaWYocyE9bnVsbClKLmRSKHMpLlIoMCwidGFyZ2V0Iil9aWYo
-cCE9bnVsbCl7cj1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIubGluZS0iK0guRWoocCkpCmlmKHIhPW51
-bGwpSi5kUihyLnBhcmVudEVsZW1lbnQpLlIoMCwiaGlnaGxpZ2h0Iil9aWYoYT09d2luZG93LmxvY2F0
-aW9uLnBhdGhuYW1lKXtMLmZHKGIsYykKZS4kMCgpfWVsc2UgTC5HNyhhLGIsYyxkLGUpfSwKUTQ6ZnVu
-Y3Rpb24oYSxiKXt2YXIgcyxyLHE9UC5oSyhhKSxwPXQuWApwPVAuRmwocCxwKQpmb3Iocz1xLmdoWSgp
-LHM9cy5nUHUocykscz1zLmdtKHMpO3MuRigpOyl7cj1zLmdsKCkKcC5ZNSgwLHIuYSxyLmIpfWZvcihz
-PWIuZ1B1KGIpLHM9cy5nbShzKTtzLkYoKTspe3I9cy5nbCgpCnAuWTUoMCxyLmEsci5iKX1wLlk1KDAs
-ImF1dGhUb2tlbiIsJC5VRSgpKQpyZXR1cm4gcS5ubSgwLHApLmduRCgpfSwKVDE6ZnVuY3Rpb24oYSl7
-dmFyIHMscixxLHAsbyxuLG0sbCxrLGo9JC5oTCgpCkoubDUoaiwiIikKaWYoYT09bnVsbCl7cz1kb2N1
-bWVudC5jcmVhdGVFbGVtZW50KCJwIikKQy5MdC5zYTQocywiU2VlIGRldGFpbHMgYWJvdXQgYSBwcm9w
-b3NlZCBlZGl0LiIpCkMuTHQuc1AocyxILlZNKFsicGxhY2Vob2xkZXIiXSx0LmkpKQpqLmFwcGVuZENo
-aWxkKHMpCkMuTHQuRkYocykKcmV0dXJufXI9YS5kCnE9JC5uVSgpCnA9cS56ZihyKQpvPWEuYgpuPWRv
-Y3VtZW50Cm09cS5IUChyLEouVDAobi5xdWVyeVNlbGVjdG9yKCIucm9vdCIpLnRleHRDb250ZW50KSkK
-bD1hLmMKaz1uLmNyZWF0ZUVsZW1lbnQoInAiKQpqLmFwcGVuZENoaWxkKGspCmsuYXBwZW5kQ2hpbGQo
-bi5jcmVhdGVUZXh0Tm9kZShILkVqKG8pKyIgYXQgIikpCnE9dC5YCnE9Vy5KNihMLlE0KGEuZSxQLkVG
-KFsibGluZSIsSi5qKGwpXSxxLHEpKSkKcS5hcHBlbmRDaGlsZChuLmNyZWF0ZVRleHROb2RlKEguRWoo
-bSkrIjoiK0guRWoobCkrIi4iKSkKay5hcHBlbmRDaGlsZChxKQpKLmRoKGspCkwuQ0MoYSxqLHApCkwu
-RnooYSxqKX0sCkxIOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxm
-LGU9JC55UCgpCkoubDUoZSwiIikKaWYoYi5nQShiKT09PTApe3M9ZG9jdW1lbnQKcj1zLmNyZWF0ZUVs
-ZW1lbnQoInAiKQplLmFwcGVuZENoaWxkKHIpCnIuYXBwZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgi
-Tm8gcHJvcG9zZWQgZWRpdHMiKSl9ZWxzZSBmb3IoZT1iLmdQdShiKSxlPWUuZ20oZSkscz10LlgscT10
-LmsscD1xLkMoIn4oMSk/Iiksbz10LloscT1xLmM7ZS5GKCk7KXtuPWUuZ2woKQptPWRvY3VtZW50CnI9
-bS5jcmVhdGVFbGVtZW50KCJwIikKbD0kLnlQKCkKbC5hcHBlbmRDaGlsZChyKQpyLmFwcGVuZENoaWxk
-KG0uY3JlYXRlVGV4dE5vZGUoSC5FaihuLmEpKyI6IikpCms9bS5jcmVhdGVFbGVtZW50KCJ1bCIpCmwu
-YXBwZW5kQ2hpbGQoaykKZm9yKG49Si5JVChuLmIpO24uRigpOyl7bD1uLmdsKCkKaj1tLmNyZWF0ZUVs
-ZW1lbnQoImxpIikKay5hcHBlbmRDaGlsZChqKQpKLmRSKGopLmkoMCwiZWRpdCIpCmk9bS5jcmVhdGVF
-bGVtZW50KCJhIikKai5hcHBlbmRDaGlsZChpKQppLmNsYXNzTGlzdC5hZGQoImVkaXQtbGluayIpCmg9
-bC5jCmc9SC5FaihoKQppLnNldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KGkpKS5P
-VSgib2Zmc2V0IiksZykKZj1sLmEKZz1ILkVqKGYpCmkuc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcu
-U3kobmV3IFcuaTcoaSkpLk9VKCJsaW5lIiksZykKaS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2Rl
-KCJsaW5lICIrSC5FaihmKSkpCmkuc2V0QXR0cmlidXRlKCJocmVmIixMLlE0KHdpbmRvdy5sb2NhdGlv
-bi5wYXRobmFtZSxQLkVGKFsibGluZSIsSC5FaihmKSwib2Zmc2V0IixILkVqKGgpXSxzLHMpKSkKZz1w
-LmEobmV3IEwuRUUoaCxmLGEpKQpvLmEobnVsbCkKVy5KRShpLCJjbGljayIsZywhMSxxKQpqLmFwcGVu
-ZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIjogIitILkVqKGwuYikpKX19aWYoYylMLlQxKG51bGwpfSwK
-RnI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscT13aW5kb3cubG9jYXRpb24scD1QLmhLKChxJiZDLkV4
-KS5nRHIocSkrSC5FaihhKSkKcT10LlgKcT1QLkZsKHEscSkKaWYoYiE9bnVsbClxLlk1KDAsIm9mZnNl
-dCIsSC5FaihiKSkKaWYoYyE9bnVsbClxLlk1KDAsImxpbmUiLEguRWooYykpCnEuWTUoMCwiYXV0aFRv
-a2VuIiwkLlVFKCkpCnA9cC5ubSgwLHEpCnE9d2luZG93Lmhpc3RvcnkKcz10LnoKcj1wLmduRCgpCnEu
-dG9TdHJpbmcKcS5wdXNoU3RhdGUobmV3IFAuQmYoW10sW10pLlB2KFAuRmwocyxzKSksIiIscil9LApF
-bjpmdW5jdGlvbihhKXt2YXIgcz1KLmJiKGRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIi5yb290IikudGV4
-dENvbnRlbnQsIi8iKQppZihDLnhCLm5DKGEscykpcmV0dXJuIEMueEIueW4oYSxzLmxlbmd0aCkKZWxz
-ZSByZXR1cm4gYX0sCk90OmZ1bmN0aW9uKGEpe3N3aXRjaChhLnIpe2Nhc2UgQy5jdzpicmVhawpjYXNl
-IEMuV0Q6YS5yPUMuWGoKYnJlYWsKY2FzZSBDLlhqOmEucj1DLldECmJyZWFrCmNhc2UgQy5kYzp0aHJv
-dyBILmIoUC5QVigiRmlsZSAiK0guRWooYS5jKSsiIHNob3VsZCBub3QgaGF2ZSBpbmRldGVybWluYXRl
-IG1pZ3JhdGlvbiBzdGF0dXMiKSl9fSwKdGE6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPSJjaGVja19ib3gi
-LHE9InRpdGxlIixwPSJvcHRlZC1vdXQiLG89Im1pZ3JhdGluZyIKc3dpdGNoKGIpe2Nhc2UgQy5jdzph
-LmlubmVyVGV4dD1yCnM9Si5ZRShhKQpzLmdQKGEpLmkoMCwiYWxyZWFkeS1taWdyYXRlZCIpCnMuZ1Ao
-YSkuaSgwLCJkaXNhYmxlZCIpCmEuc2V0QXR0cmlidXRlKHEsIkFscmVhZHkgbWlncmF0ZWQiKQpicmVh
-awpjYXNlIEMuV0Q6YS5pbm5lclRleHQ9cgpzPUouWUUoYSkKcy5nUChhKS5SKDAscCkKcy5nUChhKS5p
-KDAsbykKYS5zZXRBdHRyaWJ1dGUocSwiTWlncmF0aW5nIHRvIG51bGwgc2FmZXR5IikKYnJlYWsKY2Fz
-ZSBDLlhqOmEuaW5uZXJUZXh0PSJjaGVja19ib3hfb3V0bGluZV9ibGFuayIKcz1KLllFKGEpCnMuZ1Ao
-YSkuUigwLG8pCnMuZ1AoYSkuaSgwLHApCmEuc2V0QXR0cmlidXRlKHEsIk9wdGluZyBvdXQgb2YgbnVs
-bCBzYWZldHkiKQpicmVhawpkZWZhdWx0OmEuaW5uZXJUZXh0PSJpbmRldGVybWluYXRlX2NoZWNrX2Jv
-eCIKcz1KLllFKGEpCnMuZ1AoYSkuUigwLG8pCnMuZ1AoYSkuaSgwLHApCmEuc2V0QXR0cmlidXRlKHEs
-Ik1peGVkIHN0YXR1c2VzIG9mICdtaWdyYXRpbmcnIGFuZCAnb3B0aW5nIG91dCciKQpicmVha319LAp4
-bjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT0iZGlzYWJsZWQiLHA9Yi5nTCgpCkwudGEoYSxwKQppZihi
-LmM9PSQuRDkoKS5pbm5lclRleHQpe3M9YiBpbnN0YW5jZW9mIEwuY0QmJiFILm9UKGIueCkKcj1KLllF
-KGEpCmlmKHMpci5nUChhKS5pKDAscSkKZWxzZSByLmdQKGEpLlIoMCxxKQpMLnRhKCQuYzAoKSxwKX19
-LApCWDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT17fQpxLmE9YQphPUwuRW4oYSkKcS5hPWEKSi5kcigk
-LkQ5KCksYSkKcz1kb2N1bWVudApILkRoKHQuZyx0LmgsIlQiLCJxdWVyeVNlbGVjdG9yQWxsIikKcz1u
-ZXcgVy53eihzLnF1ZXJ5U2VsZWN0b3JBbGwoIi5uYXYtcGFuZWwgLm5hdi1saW5rIiksdC5SKQpzLkso
-cyxuZXcgTC5WUyhxKSkKcz0kLklSCnI9cz09bnVsbD9udWxsOkwueXcocyxxLmEpCmlmKHI9PW51bGwp
-Si5kUigkLmJOKCkpLlIoMCwidmlzaWJsZSIpCmVsc2V7Si5kUigkLmJOKCkpLmkoMCwidmlzaWJsZSIp
-CkwudGEoJC5jMCgpLHIuZ0woKSl9fSwKQVI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9Yi5iCmlmKHEh
-PW51bGwpe3M9dC5nCnI9cy5hKHMuYShhLnBhcmVudE5vZGUpLnBhcmVudE5vZGUpCkwueG4oci5xdWVy
-eVNlbGVjdG9yKCI6c2NvcGUgPiAuc3RhdHVzLWljb24iKSxxKQpMLkFSKHIscSl9fSwKaGw6ZnVuY3Rp
-b24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbT0iOnNjb3BlID4gLnN0YXR1cy1pY29uIgpmb3Iocz1iLmQs
-cj1zLmxlbmd0aCxxPXQuZyxwPTA7cDxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsr
-cCl7bz1zW3BdCm49YS5xdWVyeVNlbGVjdG9yKCdbZGF0YS1uYW1lKj0iJytILkVqKFcuTGooby5jKSkr
-JyJdJykKaWYobyBpbnN0YW5jZW9mIEwudnQpe0wuaGwobixvKQpMLnhuKG4ucXVlcnlTZWxlY3Rvciht
-KSxiKX1lbHNlIEwueG4ocS5hKG4ucGFyZW50Tm9kZSkucXVlcnlTZWxlY3RvcihtKSxvKX19LApCRTpm
-dW5jdGlvbihhLGIsYyl7dmFyIHM9Ii5yZWdpb25zIixyPWRvY3VtZW50LHE9ci5xdWVyeVNlbGVjdG9y
-KHMpLHA9ci5xdWVyeVNlbGVjdG9yKCIuY29kZSIpCkoudEgocSxiLmEsJC5LRygpKQpKLnRIKHAsYi5i
-LCQuS0coKSkKTC5MSChhLGIuZCxjKQppZihiLmMubGVuZ3RoPDJlNSlMLnZVKCkKTC55WCgiLmNvZGUi
-LCEwKQpMLnlYKHMsITApfSwKdFg6ZnVuY3Rpb24oYTEsYTIsYTMpe3ZhciBzLHIscSxwLG8sbixtLGws
-ayxqLGksaCxnLGYsZSxkLGM9Im1hdGVyaWFsLWljb25zIixiPSJzdGF0dXMtaWNvbiIsYT1kb2N1bWVu
-dCxhMD1hLmNyZWF0ZUVsZW1lbnQoInVsIikKYTEuYXBwZW5kQ2hpbGQoYTApCmZvcihzPWEyLmxlbmd0
-aCxyPXQuWCxxPXQuWixwPTA7cDxhMi5sZW5ndGg7YTIubGVuZ3RoPT09c3x8KDAsSC5saykoYTIpLCsr
-cCl7bz1hMltwXQpuPWEuY3JlYXRlRWxlbWVudCgibGkiKQphMC5hcHBlbmRDaGlsZChuKQppZihvIGlu
-c3RhbmNlb2YgTC52dCl7bT1KLllFKG4pCm0uZ1AobikuaSgwLCJkaXIiKQpuLnNldEF0dHJpYnV0ZSgi
-ZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KG4pKS5PVSgibmFtZSIpLG8uYykKbD1hLmNyZWF0ZUVsZW1l
-bnQoInNwYW4iKQpuLmFwcGVuZENoaWxkKGwpCms9Si5ZRShsKQprLmdQKGwpLmkoMCwiYXJyb3ciKQpr
-LnNoZihsLCImI3gyNUJDOyIpCmo9YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKSi5kUihqKS5pKDAsYykK
-ai5pbm5lclRleHQ9ImZvbGRlcl9vcGVuIgpuLmFwcGVuZENoaWxkKGopCm4uYXBwZW5kQ2hpbGQoYS5j
-cmVhdGVUZXh0Tm9kZShvLmEpKQpMLnRYKG4sby5kLCEwKQppPWEuY3JlYXRlRWxlbWVudCgic3BhbiIp
-Cms9Si5ZRShpKQprLmdQKGkpLmkoMCxjKQppLmlubmVyVGV4dD0iaW5kZXRlcm1pbmF0ZV9jaGVja19i
-b3giCmsuZ1AoaSkuaSgwLGIpCkwueG4oaSxvKQprPWsuZ1ZsKGkpCmg9ay4kdGkKZz1oLkMoIn4oMSk/
-IikuYShuZXcgTC5URChvLG4saSkpCnEuYShudWxsKQpXLkpFKGsuYSxrLmIsZywhMSxoLmMpCm0ubUso
-bixpLGopCkwua3oobCl9ZWxzZSBpZihvIGluc3RhbmNlb2YgTC5jRCl7aT1hLmNyZWF0ZUVsZW1lbnQo
-InNwYW4iKQptPUouWUUoaSkKbS5nUChpKS5pKDAsYykKaS5pbm5lclRleHQ9IiIKbS5nUChpKS5pKDAs
-YikKaz1ILm9UKG8ueCkKaWYoIWspbS5nUChpKS5pKDAsImRpc2FibGVkIikKTC54bihpLG8pCmlmKGsp
-e209bS5nVmwoaSkKaz1tLiR0aQpoPWsuQygifigxKT8iKS5hKG5ldyBMLklmKG8saSxuKSkKcS5hKG51
-bGwpClcuSkUobS5hLG0uYixoLCExLGsuYyl9bi5hcHBlbmRDaGlsZChpKQptPWEuY3JlYXRlRWxlbWVu
-dCgic3BhbiIpCkouZFIobSkuaSgwLGMpCm0uaW5uZXJUZXh0PSJpbnNlcnRfZHJpdmVfZmlsZSIKbi5h
-cHBlbmRDaGlsZChtKQpmPWEuY3JlYXRlRWxlbWVudCgiYSIpCm4uYXBwZW5kQ2hpbGQoZikKbT1KLllF
-KGYpCm0uZ1AoZikuaSgwLCJuYXYtbGluayIpCmYuc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3ko
-bmV3IFcuaTcoZikpLk9VKCJuYW1lIiksby5jKQpmLnNldEF0dHJpYnV0ZSgiaHJlZiIsTC5RNChvLmQs
-UC5GbChyLHIpKSkKZi5hcHBlbmRDaGlsZChhLmNyZWF0ZVRleHROb2RlKG8uYSkpCm09bS5nVmwoZikK
-az1tLiR0aQpoPWsuQygifigxKT8iKS5hKG5ldyBMLnRCKCkpCnEuYShudWxsKQpXLkpFKG0uYSxtLmIs
-aCwhMSxrLmMpCmU9by5lCmlmKHR5cGVvZiBlIT09Im51bWJlciIpcmV0dXJuIGUub3MoKQppZihlPjAp
-e2Q9YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKbi5hcHBlbmRDaGlsZChkKQpKLmRSKGQpLmkoMCwiZWRp
-dC1jb3VudCIpCm09IiIrZSsiICIKaWYoZT09PTEpaz0icHJvcG9zZWQgZWRpdCIKZWxzZSBrPSJwcm9w
-b3NlZCBlZGl0cyIKZC5zZXRBdHRyaWJ1dGUoInRpdGxlIixtK2spCmQuYXBwZW5kQ2hpbGQoYS5jcmVh
-dGVUZXh0Tm9kZShDLmpuLncoZSkpKX19fX0sCnV6OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1kb2N1bWVu
-dCxyPXMuY3JlYXRlRWxlbWVudCgiYnV0dG9uIikscT10LmsscD1xLkMoIn4oMSk/IikuYShuZXcgTC5t
-MihhLGMpKQp0LlouYShudWxsKQpXLkpFKHIsImNsaWNrIixwLCExLHEuYykKci5hcHBlbmRDaGlsZChz
-LmNyZWF0ZVRleHROb2RlKFIuT1goYS5hKSkpCmIuYXBwZW5kQ2hpbGQocil9LApGejpmdW5jdGlvbihh
-LGIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaD1hLmEKaWYoaD09bnVsbClyZXR1cm4Kcz1kb2N1
-bWVudApyPXMuY3JlYXRlRWxlbWVudCgicCIpCnE9Yi5hcHBlbmRDaGlsZChyKQpyPXMuY3JlYXRlRWxl
-bWVudCgic3BhbiIpCnA9dC5pCkouTXUocixILlZNKFsidHlwZS1kZXNjcmlwdGlvbiJdLHApKQpyLmFw
-cGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUoIkFjdGlvbnMiKSkKcS5hcHBlbmRDaGlsZChyKQpxLmFw
-cGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUoIjoiKSkKbz1zLmNyZWF0ZUVsZW1lbnQoInAiKQpiLmFw
-cGVuZENoaWxkKG8pCmZvcihyPWgubGVuZ3RoLG49dC5RLG09MDttPGgubGVuZ3RoO2gubGVuZ3RoPT09
-cnx8KDAsSC5saykoaCksKyttKXtsPWhbbV0Kaz1zLmNyZWF0ZUVsZW1lbnQoImEiKQpvLmFwcGVuZENo
-aWxkKGspCmsuYXBwZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZShsLmEpKQprLnNldEF0dHJpYnV0ZSgi
-aHJlZiIsbC5iKQpqPW4uYShILlZNKFsiYWRkLWhpbnQtbGluayIsImJlZm9yZS1hcHBseSIsImJ1dHRv
-biJdLHApKQppPUouZFIoaykKaS5WMSgwKQppLkZWKDAsail9fSwKQ0M6ZnVuY3Rpb24oYTQsYTUsYTYp
-e3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZSxkLGMsYixhLGEwLGExLGEyLGEzCmZvcihz
-PWE0LmYscj1zLmxlbmd0aCxxPXQuaSxwPXQuUSxvPTA7bzxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgw
-LEgubGspKHMpLCsrbyl7bj1zW29dCm09ZG9jdW1lbnQKbD1tLmNyZWF0ZUVsZW1lbnQoInAiKQprPXAu
-YShILlZNKFsidHJhY2UiXSxxKSkKaj1KLmRSKGwpCmouVjEoMCkKai5GVigwLGspCmk9YTUuYXBwZW5k
-Q2hpbGQobCkKbD1tLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQprPXAuYShILlZNKFsidHlwZS1kZXNjcmlw
-dGlvbiJdLHEpKQpqPUouZFIobCkKai5WMSgwKQpqLkZWKDAsaykKbC5hcHBlbmRDaGlsZChtLmNyZWF0
-ZVRleHROb2RlKG4uYSkpCmkuYXBwZW5kQ2hpbGQobCkKaS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHRO
-b2RlKCI6IikpCmw9bS5jcmVhdGVFbGVtZW50KCJ1bCIpCms9cC5hKEguVk0oWyJ0cmFjZSJdLHEpKQpq
-PUouZFIobCkKai5WMSgwKQpqLkZWKDAsaykKaD1pLmFwcGVuZENoaWxkKGwpCmZvcihsPW4uYixrPWwu
-bGVuZ3RoLGc9MDtnPGwubGVuZ3RoO2wubGVuZ3RoPT09a3x8KDAsSC5saykobCksKytnKXtmPWxbZ10K
-ZT1tLmNyZWF0ZUVsZW1lbnQoImxpIikKaC5hcHBlbmRDaGlsZChlKQpkPW0uY3JlYXRlRWxlbWVudCgi
-c3BhbiIpCmM9cC5hKEguVk0oWyJmdW5jdGlvbiJdLHEpKQpqPUouZFIoZCkKai5WMSgwKQpqLkZWKDAs
-YykKYz1mLmIKTC5XaihkLGM9PW51bGw/InVua25vd24iOmMpCmUuYXBwZW5kQ2hpbGQoZCkKYj1mLmMK
-aWYoYiE9bnVsbCl7ZS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKCIgKCIpKQphPWIuYgphMD1t
-LmNyZWF0ZUVsZW1lbnQoImEiKQphMC5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKEguRWooYi5j
-KSsiOiIrSC5FaihhKSkpCmEwLnNldEF0dHJpYnV0ZSgiaHJlZiIsYi5hKQphMC5jbGFzc0xpc3QuYWRk
-KCJuYXYtbGluayIpCmUuYXBwZW5kQ2hpbGQoYTApCmUuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9k
-ZSgiKSIpKX1lLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIjogIikpCmQ9Zi5hCkwuV2ooZSxk
-PT1udWxsPyJ1bmtub3duIjpkKQpkPWYuZAppZihkLmxlbmd0aCE9PTApe2M9bS5jcmVhdGVFbGVtZW50
-KCJwIikKYTE9cC5hKEguVk0oWyJkcmF3ZXIiLCJiZWZvcmUtYXBwbHkiXSxxKSkKaj1KLmRSKGMpCmou
-VjEoMCkKai5GVigwLGExKQphMj1lLmFwcGVuZENoaWxkKGMpCmZvcihjPWQubGVuZ3RoLGEzPTA7YTM8
-ZC5sZW5ndGg7ZC5sZW5ndGg9PT1jfHwoMCxILmxrKShkKSwrK2EzKUwudXooZFthM10sYTIsYil9fX19
-LApVczpmdW5jdGlvbihhKXtyZXR1cm4gSi56bChhLCI/Iik/Qy54Qi5OaihhLDAsQy54Qi5PWShhLCI/
-IikpOmF9LApURzpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgTC5RVyhhLGIpfSwKeXc6ZnVuY3Rpb24o
-YSxiKXt2YXIgcyxyLHEscApmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDthLmxlbmd0aD09PXN8
-fCgwLEgubGspKGEpLCsrcil7cT1hW3JdCmlmKHEgaW5zdGFuY2VvZiBMLnZ0KXtwPUwueXcocS5kLGIp
-CmlmKHAhPW51bGwpcmV0dXJuIHB9ZWxzZSBpZihxLmM9PWIpcmV0dXJuIHF9cmV0dXJuIG51bGx9LApX
-ajpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1ILlZNKGIuc3BsaXQoIi4iKSx0LnMpLHA9Qy5ObS5ndEgo
-cSksbz1kb2N1bWVudAphLmFwcGVuZENoaWxkKG8uY3JlYXRlVGV4dE5vZGUocCkpCmZvcihwPUgucUMo
-cSwxLG51bGwsdC5OKSxwPW5ldyBILmE3KHAscC5nQShwKSxwLiR0aS5DKCJhNzxhTC5FPiIpKSxzPUou
-WUUoYSk7cC5GKCk7KXtyPXAuZApzLm56KGEsImJlZm9yZWVuZCIsIiYjODIwMzsuIixudWxsLG51bGwp
-CmEuYXBwZW5kQ2hpbGQoby5jcmVhdGVUZXh0Tm9kZShyKSl9fSwKZTpmdW5jdGlvbiBlKCl7fSwKVlc6
-ZnVuY3Rpb24gVlcoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKb1o6ZnVuY3Rpb24g
-b1ooKXt9LApqcjpmdW5jdGlvbiBqcigpe30sCnFsOmZ1bmN0aW9uIHFsKCl7fSwKSGk6ZnVuY3Rpb24g
-SGkoKXt9LApCVDpmdW5jdGlvbiBCVCgpe30sClBZOmZ1bmN0aW9uIFBZKCl7fSwKdTg6ZnVuY3Rpb24g
-dTgoKXt9LApMOmZ1bmN0aW9uIEwoKXt9LApXeDpmdW5jdGlvbiBXeChhLGIpe3RoaXMuYT1hCnRoaXMu
-Yj1ifSwKQU86ZnVuY3Rpb24gQU8oYSl7dGhpcy5hPWF9LApkTjpmdW5jdGlvbiBkTihhKXt0aGlzLmE9
-YX0sCkhvOmZ1bmN0aW9uIEhvKGEpe3RoaXMuYT1hfSwKeHo6ZnVuY3Rpb24geHooYSxiKXt0aGlzLmE9
-YQp0aGlzLmI9Yn0sCklDOmZ1bmN0aW9uIElDKCl7fSwKZkM6ZnVuY3Rpb24gZkMoYSxiKXt0aGlzLmE9
-YQp0aGlzLmI9Yn0sClRtOmZ1bmN0aW9uIFRtKCl7fSwKblQ6ZnVuY3Rpb24gblQoYSxiLGMpe3RoaXMu
-YT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKTlk6ZnVuY3Rpb24gTlkoYSl7dGhpcy5hPWF9LAp1ZTpmdW5j
-dGlvbiB1ZSgpe30sCmVYOmZ1bmN0aW9uIGVYKCl7fSwKRUU6ZnVuY3Rpb24gRUUoYSxiLGMpe3RoaXMu
-YT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKUUw6ZnVuY3Rpb24gUUwoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
-Yn0sClZTOmZ1bmN0aW9uIFZTKGEpe3RoaXMuYT1hfSwKVEQ6ZnVuY3Rpb24gVEQoYSxiLGMpe3RoaXMu
-YT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKSWY6ZnVuY3Rpb24gSWYoYSxiLGMpe3RoaXMuYT1hCnRoaXMu
-Yj1iCnRoaXMuYz1jfSwKdEI6ZnVuY3Rpb24gdEIoKXt9LAptMjpmdW5jdGlvbiBtMihhLGIpe3RoaXMu
-YT1hCnRoaXMuYj1ifSwKUVc6ZnVuY3Rpb24gUVcoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sClhBOmZ1
-bmN0aW9uIFhBKCl7fSwKWnM6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUouVTYoYSkKaWYoTC5wMihILmgo
-cS5xKGEsInR5cGUiKSkpPT09Qy5ZMil7cz1ILmgocS5xKGEsIm5hbWUiKSkKcj1ILmgocS5xKGEsInBh
-dGgiKSkKcT1xLnEoYSwic3VidHJlZSIpCnE9bmV3IEwudnQocT09bnVsbD9udWxsOkwubUsocSkscyxy
-KQpxLkxWKCkKcmV0dXJuIHF9ZWxzZXtzPUguaChxLnEoYSwibmFtZSIpKQpyPUguaChxLnEoYSwicGF0
-aCIpKQpyZXR1cm4gbmV3IEwuY0QoSC5oKHEucShhLCJocmVmIikpLEgudVAocS5xKGEsImVkaXRDb3Vu
-dCIpKSxILnk4KHEucShhLCJ3YXNFeHBsaWNpdGx5T3B0ZWRPdXQiKSksTC52QihILnVQKHEucShhLCJt
-aWdyYXRpb25TdGF0dXMiKSkpLEgueTgocS5xKGEsIm1pZ3JhdGlvblN0YXR1c0NhbkJlQ2hhbmdlZCIp
-KSxzLHIpfX0sCm1LOmZ1bmN0aW9uKGEpe3ZhciBzLHI9SC5WTShbXSx0LmNRKQpmb3Iocz1KLklUKHQu
-VS5hKGEpKTtzLkYoKTspci5wdXNoKEwuWnMocy5nbCgpKSkKcmV0dXJuIHJ9LApWRDpmdW5jdGlvbihh
-KXt2YXIgcyxyLHE9SC5WTShbXSx0LkcpCmZvcihzPWEubGVuZ3RoLHI9MDtyPGEubGVuZ3RoO2EubGVu
-Z3RoPT09c3x8KDAsSC5saykoYSksKytyKXEucHVzaChhW3JdLkx0KCkpCnJldHVybiBxfSwKdkI6ZnVu
-Y3Rpb24oYSl7aWYoYT09bnVsbClyZXR1cm4gbnVsbAppZihhPj4+MCE9PWF8fGE+PTQpcmV0dXJuIEgu
-T0goQy5sMCxhKQpyZXR1cm4gQy5sMFthXX0sCnAyOmZ1bmN0aW9uKGEpe3N3aXRjaChhKXtjYXNlImRp
-cmVjdG9yeSI6cmV0dXJuIEMuWTIKY2FzZSJmaWxlIjpyZXR1cm4gQy5yZgpkZWZhdWx0OnRocm93IEgu
-YihQLlBWKCJVbnJlY29nbml6ZWQgbmF2aWdhdGlvbiB0cmVlIG5vZGUgdHlwZTogIitILkVqKGEpKSl9
-fSwKdnQ6ZnVuY3Rpb24gdnQoYSxiLGMpe3ZhciBfPXRoaXMKXy5kPWEKXy5hPWIKXy5iPW51bGwKXy5j
-PWN9LApjRDpmdW5jdGlvbiBjRChhLGIsYyxkLGUsZixnKXt2YXIgXz10aGlzCl8uZD1hCl8uZT1iCl8u
-Zj1jCl8ucj1kCl8ueD1lCl8uYT1mCl8uYj1udWxsCl8uYz1nfSwKRDg6ZnVuY3Rpb24gRDgoKXt9LApP
-OTpmdW5jdGlvbiBPOShhKXt0aGlzLmI9YX0sCkdiOmZ1bmN0aW9uIEdiKGEsYil7dGhpcy5hPWEKdGhp
-cy5iPWJ9LApJVjpmdW5jdGlvbiBJVihhLGIsYyxkKXt2YXIgXz10aGlzCl8uZD1hCl8uZT1iCl8uZj1j
-Cl8ucj1kfX0sUj17Cm56OmZ1bmN0aW9uKGEpe3ZhciBzPUgudVAoYS5xKDAsIm5vZGVJZCIpKQpyZXR1
-cm4gbmV3IFIuTEwoQy5ObS5IdChDLnJrLG5ldyBSLk1EKGEpKSxzKX0sCk9YOmZ1bmN0aW9uKGEpe3N3
-aXRjaChhKXtjYXNlIEMuQWQ6cmV0dXJuIkFkZCAvKj8qLyBoaW50IgpjYXNlIEMubmU6cmV0dXJuIkFk
-ZCAvKiEqLyBoaW50IgpjYXNlIEMud1Y6cmV0dXJuIlJlbW92ZSAvKj8qLyBoaW50IgpjYXNlIEMuZlI6
-cmV0dXJuIlJlbW92ZSAvKiEqLyBoaW50IgpjYXNlIEMubXk6cmV0dXJuIkNoYW5nZSB0byAvKj8qLyBo
-aW50IgpjYXNlIEMucng6cmV0dXJuIkNoYW5nZSB0byAvKiEqLyBoaW50In1yZXR1cm4gbnVsbH0sCkxM
-OmZ1bmN0aW9uIExMKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApNRDpmdW5jdGlvbiBNRChhKXt0aGlz
-LmE9YX0sCkg3OmZ1bmN0aW9uIEg3KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9fSxNPXsKWUY6ZnVuY3Rp
-b24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsCmZvcihzPWIubGVuZ3RoLHI9MTtyPHM7KytyKXtpZihi
-W3JdPT1udWxsfHxiW3ItMV0hPW51bGwpY29udGludWUKZm9yKDtzPj0xO3M9cSl7cT1zLTEKaWYoYltx
-XSE9bnVsbClicmVha31wPW5ldyBQLlJuKCIiKQpvPWErIigiCnAuYT1vCm49SC50NihiKQptPW4uQygi
-bkg8MT4iKQpsPW5ldyBILm5IKGIsMCxzLG0pCmwuSGQoYiwwLHMsbi5jKQptPW8rbmV3IEgubEoobCxt
-LkMoInFVKGFMLkUpIikuYShuZXcgTS5ObygpKSxtLkMoImxKPGFMLkUscVU+IikpLmsoMCwiLCAiKQpw
-LmE9bQpwLmE9bSsoIik6IHBhcnQgIisoci0xKSsiIHdhcyBudWxsLCBidXQgcGFydCAiK3IrIiB3YXMg
-bm90LiIpCnRocm93IEguYihQLnhZKHAudygwKSkpfX0sCmxJOmZ1bmN0aW9uIGxJKGEpe3RoaXMuYT1h
-fSwKcTc6ZnVuY3Rpb24gcTcoKXt9LApObzpmdW5jdGlvbiBObygpe319LFg9ewpDTDpmdW5jdGlvbihh
-LGIpe3ZhciBzLHIscSxwLG8sbj1iLnhaKGEpCmIuaEsoYSkKaWYobiE9bnVsbClhPUouS1YoYSxuLmxl
-bmd0aCkKcz10LnMKcj1ILlZNKFtdLHMpCnE9SC5WTShbXSxzKQpzPWEubGVuZ3RoCmlmKHMhPT0wJiZi
-LnI0KEMueEIuVyhhLDApKSl7aWYoMD49cylyZXR1cm4gSC5PSChhLDApCkMuTm0uaShxLGFbMF0pCnA9
-MX1lbHNle0MuTm0uaShxLCIiKQpwPTB9Zm9yKG89cDtvPHM7KytvKWlmKGIucjQoQy54Qi5XKGEsbykp
-KXtDLk5tLmkocixDLnhCLk5qKGEscCxvKSkKQy5ObS5pKHEsYVtvXSkKcD1vKzF9aWYocDxzKXtDLk5t
-LmkocixDLnhCLnluKGEscCkpCkMuTm0uaShxLCIiKX1yZXR1cm4gbmV3IFguV0QoYixuLHIscSl9LApX
-RDpmdW5jdGlvbiBXRChhLGIsYyxkKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uZD1jCl8uZT1kfSwK
-STc6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBYLmR2KGEpfSwKZHY6ZnVuY3Rpb24gZHYoYSl7dGhpcy5h
-PWF9fSxPPXsKUmg6ZnVuY3Rpb24oKXt2YXIgcyxyPW51bGwKaWYoUC51bygpLmdGaSgpIT09ImZpbGUi
-KXJldHVybiAkLkViKCkKcz1QLnVvKCkKaWYoIUMueEIuVGMocy5nSWkocyksIi8iKSlyZXR1cm4gJC5F
-YigpCmlmKFAuS0wociwiYS9iIixyLHIscixyLHIpLnQ0KCk9PT0iYVxcYiIpcmV0dXJuICQuS2soKQpy
-ZXR1cm4gJC5iRCgpfSwKekw6ZnVuY3Rpb24gekwoKXt9fSxFPXtPRjpmdW5jdGlvbiBPRihhLGIsYyl7
-dGhpcy5kPWEKdGhpcy5lPWIKdGhpcy5mPWN9fSxGPXtydTpmdW5jdGlvbiBydShhLGIsYyxkKXt2YXIg
-Xz10aGlzCl8uZD1hCl8uZT1iCl8uZj1jCl8ucj1kfX0sRD17CmFiOmZ1bmN0aW9uKCl7dmFyIHMscixx
-LHAsbz1udWxsCnRyeXtvPVAudW8oKX1jYXRjaChzKXtpZih0Lmc4LmIoSC5SdShzKSkpe3I9JC5GZgpp
-ZihyIT1udWxsKXJldHVybiByCnRocm93IHN9ZWxzZSB0aHJvdyBzfWlmKEouUk0obywkLkk2KSl7cj0k
-LkZmCnIudG9TdHJpbmcKcmV0dXJuIHJ9JC5JNj1vCmlmKCQuSGsoKT09JC5FYigpKXI9JC5GZj1vLlpJ
-KCIuIikudygwKQplbHNle3E9by50NCgpCnA9cS5sZW5ndGgtMQpyPSQuRmY9cD09PTA/cTpDLnhCLk5q
-KHEsMCxwKX1yLnRvU3RyaW5nCnJldHVybiByfX0KdmFyIHc9W0MsSCxKLFAsVyxVLEIsVCxMLFIsTSxY
-LE8sRSxGLERdCmh1bmtIZWxwZXJzLnNldEZ1bmN0aW9uTmFtZXNJZk5lY2Vzc2FyeSh3KQp2YXIgJD17
-fQpILkZLLnByb3RvdHlwZT17fQpKLkd2LnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7cmV0dXJu
-IGE9PT1ifSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBILmVRKGEpfSwKdzpmdW5jdGlvbihhKXtyZXR1
-cm4iSW5zdGFuY2Ugb2YgJyIrSC5FaihILk0oYSkpKyInIn0sCmU3OmZ1bmN0aW9uKGEsYil7dC5vLmEo
-YikKdGhyb3cgSC5iKFAubHIoYSxiLmdXYSgpLGIuZ25kKCksYi5nVm0oKSkpfX0KSi55RS5wcm90b3R5
-cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9LApnaU86ZnVuY3Rpb24oYSl7cmV0dXJu
-IGE/NTE5MDE4OjIxODE1OX0sCiRpYTI6MX0KSi53ZS5wcm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIp
-e3JldHVybiBudWxsPT1ifSwKdzpmdW5jdGlvbihhKXtyZXR1cm4ibnVsbCJ9LApnaU86ZnVuY3Rpb24o
-YSl7cmV0dXJuIDB9LAplNzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlNqKGEsdC5vLmEoYikpfSwK
-JGljODoxfQpKLk1GLnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gMH0sCnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIFN0cmluZyhhKX0sCiRpdm06MX0KSi5pQy5wcm90b3R5cGU9e30KSi5rZC5wcm90
-b3R5cGU9e30KSi5jNS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPWFbJC53KCldCmlmKHM9
-PW51bGwpcmV0dXJuIHRoaXMudChhKQpyZXR1cm4iSmF2YVNjcmlwdCBmdW5jdGlvbiBmb3IgIitILkVq
-KEouaihzKSl9LAokaUVIOjF9CkouamQucHJvdG90eXBlPXsKZHI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4g
-bmV3IEgualYoYSxILnQ2KGEpLkMoIkA8MT4iKS5LcShiKS5DKCJqVjwxLDI+IikpfSwKaTpmdW5jdGlv
-bihhLGIpe0gudDYoYSkuYy5hKGIpCmlmKCEhYS5maXhlZCRsZW5ndGgpSC52KFAuTDQoImFkZCIpKQph
-LnB1c2goYil9LApXNDpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKCEhYS5maXhlZCRsZW5ndGgpSC52KFAu
-TDQoInJlbW92ZUF0IikpCnM9YS5sZW5ndGgKaWYoYj49cyl0aHJvdyBILmIoUC5PNyhiLG51bGwpKQpy
-ZXR1cm4gYS5zcGxpY2UoYiwxKVswXX0sClVHOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCkgudDYoYSku
-QygiY1g8MT4iKS5hKGMpCmlmKCEhYS5maXhlZCRsZW5ndGgpSC52KFAuTDQoImluc2VydEFsbCIpKQpQ
-LndBKGIsMCxhLmxlbmd0aCwiaW5kZXgiKQppZighdC5kLmIoYykpYz1KLlJYKGMpCnM9Si5IbShjKQph
-Lmxlbmd0aD1hLmxlbmd0aCtzCnI9YitzCnRoaXMuWVcoYSxyLGEubGVuZ3RoLGEsYikKdGhpcy52Zyhh
-LGIscixjKX0sCkZWOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC50NihhKS5DKCJjWDwxPiIpLmEoYikKaWYo
-ISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiYWRkQWxsIikpCmlmKEFycmF5LmlzQXJyYXkoYikpe3Ro
-aXMuS2goYSxiKQpyZXR1cm59Zm9yKHM9Si5JVChiKTtzLkYoKTspYS5wdXNoKHMuZ2woKSl9LApLaDpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIKdC5iLmEoYikKcz1iLmxlbmd0aAppZihzPT09MClyZXR1cm4KaWYo
-YT09PWIpdGhyb3cgSC5iKFAuYTQoYSkpCmZvcihyPTA7cjxzOysrcilhLnB1c2goYltyXSl9LApFMjpm
-dW5jdGlvbihhLGIsYyl7dmFyIHM9SC50NihhKQpyZXR1cm4gbmV3IEgubEooYSxzLktxKGMpLkMoIjEo
-MikiKS5hKGIpLHMuQygiQDwxPiIpLktxKGMpLkMoImxKPDEsMj4iKSl9LAprOmZ1bmN0aW9uKGEsYil7
-dmFyIHMscj1QLk84KGEubGVuZ3RoLCIiLCExLHQuTikKZm9yKHM9MDtzPGEubGVuZ3RoOysrcyl0aGlz
-Llk1KHIscyxILkVqKGFbc10pKQpyZXR1cm4gci5qb2luKGIpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1
-cm4gSC5xQyhhLGIsbnVsbCxILnQ2KGEpLmMpfSwKTjA6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixx
-CmQuYShiKQpILnQ2KGEpLktxKGQpLkMoIjEoMSwyKSIpLmEoYykKcz1hLmxlbmd0aApmb3Iocj1iLHE9
-MDtxPHM7KytxKXtyPWMuJDIocixhW3FdKQppZihhLmxlbmd0aCE9PXMpdGhyb3cgSC5iKFAuYTQoYSkp
-fXJldHVybiByfSwKSHQ6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCkgudDYoYSkuQygiYTIoMSki
-KS5hKGIpCnM9YS5sZW5ndGgKZm9yKHI9bnVsbCxxPSExLHA9MDtwPHM7KytwKXtvPWFbcF0KaWYoSC5v
-VChiLiQxKG8pKSl7aWYocSl0aHJvdyBILmIoSC5BbSgpKQpyPW8KcT0hMH1pZihzIT09YS5sZW5ndGgp
-dGhyb3cgSC5iKFAuYTQoYSkpfWlmKHEpcmV0dXJuIHIKdGhyb3cgSC5iKEguV3AoKSl9LApFOmZ1bmN0
-aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1cm4gSC5PSChhLGIpCnJldHVybiBhW2JdfSwK
-Z3RIOmZ1bmN0aW9uKGEpe2lmKGEubGVuZ3RoPjApcmV0dXJuIGFbMF0KdGhyb3cgSC5iKEguV3AoKSl9
-LApnclo6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz4wKXJldHVybiBhW3MtMV0KdGhyb3cg
-SC5iKEguV3AoKSl9LApZVzpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8KSC50NihhKS5D
-KCJjWDwxPiIpLmEoZCkKaWYoISFhLmltbXV0YWJsZSRsaXN0KUgudihQLkw0KCJzZXRSYW5nZSIpKQpQ
-LmpCKGIsYyxhLmxlbmd0aCkKcz1jLWIKaWYocz09PTApcmV0dXJuClAuazEoZSwic2tpcENvdW50IikK
-aWYodC5qLmIoZCkpe3I9ZApxPWV9ZWxzZXtyPUouQTUoZCxlKS50dCgwLCExKQpxPTB9cD1KLlU2KHIp
-CmlmKHErcz5wLmdBKHIpKXRocm93IEguYihILmFyKCkpCmlmKHE8Yilmb3Iobz1zLTE7bz49MDstLW8p
-YVtiK29dPXAucShyLHErbykKZWxzZSBmb3Iobz0wO288czsrK28pYVtiK29dPXAucShyLHErbyl9LAp2
-ZzpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gdGhpcy5ZVyhhLGIsYyxkLDApfSwKVnI6ZnVuY3Rpb24o
-YSxiKXt2YXIgcyxyCkgudDYoYSkuQygiYTIoMSkiKS5hKGIpCnM9YS5sZW5ndGgKZm9yKHI9MDtyPHM7
-KytyKXtpZihILm9UKGIuJDEoYVtyXSkpKXJldHVybiEwCmlmKGEubGVuZ3RoIT09cyl0aHJvdyBILmIo
-UC5hNChhKSl9cmV0dXJuITF9LAp0ZzpmdW5jdGlvbihhLGIpe3ZhciBzCmZvcihzPTA7czxhLmxlbmd0
-aDsrK3MpaWYoSi5STShhW3NdLGIpKXJldHVybiEwCnJldHVybiExfSwKZ2wwOmZ1bmN0aW9uKGEpe3Jl
-dHVybiBhLmxlbmd0aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RoIT09MH0sCnc6
-ZnVuY3Rpb24oYSl7cmV0dXJuIFAuV0UoYSwiWyIsIl0iKX0sCnR0OmZ1bmN0aW9uKGEsYil7dmFyIHM9
-SC5WTShhLnNsaWNlKDApLEgudDYoYSkpCnJldHVybiBzfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
-aXMudHQoYSwhMCl9LApnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEoubTEoYSxhLmxlbmd0aCxILnQ2
-KGEpLkMoIm0xPDE+IikpfSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBILmVRKGEpfSwKZ0E6ZnVuY3Rp
-b24oYSl7cmV0dXJuIGEubGVuZ3RofSwKc0E6ZnVuY3Rpb24oYSxiKXtpZighIWEuZml4ZWQkbGVuZ3Ro
-KUgudihQLkw0KCJzZXQgbGVuZ3RoIikpCmlmKGI8MCl0aHJvdyBILmIoUC5URShiLDAsbnVsbCwibmV3
-TGVuZ3RoIixudWxsKSkKYS5sZW5ndGg9Yn0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+PWEu
-bGVuZ3RofHxiPDApdGhyb3cgSC5iKEguSFkoYSxiKSkKcmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihh
-LGIsYyl7SC50NihhKS5jLmEoYykKaWYoISFhLmltbXV0YWJsZSRsaXN0KUgudihQLkw0KCJpbmRleGVk
-IHNldCIpKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93IEguYihILkhZKGEsYikpCmFbYl09Y30sCiRp
-YlE6MSwKJGljWDoxLAokaXpNOjF9CkouUG8ucHJvdG90eXBlPXt9CkoubTEucHJvdG90eXBlPXsKZ2w6
-ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxw
-PXEubGVuZ3RoCmlmKHIuYiE9PXApdGhyb3cgSC5iKEgubGsocSkpCnM9ci5jCmlmKHM+PXApe3Iuc00o
-bnVsbCkKcmV0dXJuITF9ci5zTShxW3NdKTsrK3IuYwpyZXR1cm4hMH0sCnNNOmZ1bmN0aW9uKGEpe3Ro
-aXMuZD10aGlzLiR0aS5DKCIxPyIpLmEoYSl9LAokaUFuOjF9CkoucUkucHJvdG90eXBlPXsKelE6ZnVu
-Y3Rpb24oYSl7aWYoYT4wKXtpZihhIT09MS8wKXJldHVybiBNYXRoLnJvdW5kKGEpfWVsc2UgaWYoYT4t
-MS8wKXJldHVybiAwLU1hdGgucm91bmQoMC1hKQp0aHJvdyBILmIoUC5MNCgiIithKyIucm91bmQoKSIp
-KX0sCnc6ZnVuY3Rpb24oYSl7aWYoYT09PTAmJjEvYTwwKXJldHVybiItMC4wIgplbHNlIHJldHVybiIi
-K2F9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbz1hfDAKaWYoYT09PW8pcmV0dXJuIG8mNTM2
-ODcwOTExCnM9TWF0aC5hYnMoYSkKcj1NYXRoLmxvZyhzKS8wLjY5MzE0NzE4MDU1OTk0NTN8MApxPU1h
-dGgucG93KDIscikKcD1zPDE/cy9xOnEvcwpyZXR1cm4oKHAqOTAwNzE5OTI1NDc0MDk5MnwwKSsocCoz
-NTQyMjQzMTgxMTc2NTIxfDApKSo1OTkxOTcrcioxMjU5JjUzNjg3MDkxMX0sCnpZOmZ1bmN0aW9uKGEs
-Yil7dmFyIHM9YSViCmlmKHM9PT0wKXJldHVybiAwCmlmKHM+MClyZXR1cm4gcwppZihiPDApcmV0dXJu
-IHMtYgplbHNlIHJldHVybiBzK2J9LApCVTpmdW5jdGlvbihhLGIpe3JldHVybihhfDApPT09YT9hL2J8
-MDp0aGlzLkRKKGEsYil9LApESjpmdW5jdGlvbihhLGIpe3ZhciBzPWEvYgppZihzPj0tMjE0NzQ4MzY0
-OCYmczw9MjE0NzQ4MzY0NylyZXR1cm4gc3wwCmlmKHM+MCl7aWYocyE9PTEvMClyZXR1cm4gTWF0aC5m
-bG9vcihzKX1lbHNlIGlmKHM+LTEvMClyZXR1cm4gTWF0aC5jZWlsKHMpCnRocm93IEguYihQLkw0KCJS
-ZXN1bHQgb2YgdHJ1bmNhdGluZyBkaXZpc2lvbiBpcyAiK0guRWoocykrIjogIitILkVqKGEpKyIgfi8g
-IitiKSl9LAp3RzpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKGE+MClzPXRoaXMucDMoYSxiKQplbHNle3M9
-Yj4zMT8zMTpiCnM9YT4+cz4+PjB9cmV0dXJuIHN9LApiZjpmdW5jdGlvbihhLGIpe2lmKGI8MCl0aHJv
-dyBILmIoSC50TChiKSkKcmV0dXJuIHRoaXMucDMoYSxiKX0sCnAzOmZ1bmN0aW9uKGEsYil7cmV0dXJu
-IGI+MzE/MDphPj4+Yn0sCiRpQ1A6MSwKJGlaWjoxfQpKLmJVLnByb3RvdHlwZT17JGlJajoxfQpKLmtE
-LnByb3RvdHlwZT17fQpKLkRyLnByb3RvdHlwZT17Ck86ZnVuY3Rpb24oYSxiKXtpZihiPDApdGhyb3cg
-SC5iKEguSFkoYSxiKSkKaWYoYj49YS5sZW5ndGgpSC52KEguSFkoYSxiKSkKcmV0dXJuIGEuY2hhckNv
-ZGVBdChiKX0sClc6ZnVuY3Rpb24oYSxiKXtpZihiPj1hLmxlbmd0aCl0aHJvdyBILmIoSC5IWShhLGIp
-KQpyZXR1cm4gYS5jaGFyQ29kZUF0KGIpfSwKZGQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEgudW4o
-YixhLDApfSwKaDpmdW5jdGlvbihhLGIpe2lmKHR5cGVvZiBiIT0ic3RyaW5nIil0aHJvdyBILmIoUC5M
-MyhiLG51bGwsbnVsbCkpCnJldHVybiBhK2J9LApUYzpmdW5jdGlvbihhLGIpe3ZhciBzPWIubGVuZ3Ro
-LHI9YS5sZW5ndGgKaWYocz5yKXJldHVybiExCnJldHVybiBiPT09dGhpcy55bihhLHItcyl9LAppNzpm
-dW5jdGlvbihhLGIsYyxkKXt2YXIgcz1QLmpCKGIsYyxhLmxlbmd0aCkscj1hLnN1YnN0cmluZygwLGIp
-LHE9YS5zdWJzdHJpbmcocykKcmV0dXJuIHIrZCtxfSwKUWk6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCmlm
-KGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAsYS5sZW5ndGgsbnVsbCxudWxsKSkKcz1j
-K2IubGVuZ3RoCmlmKHM+YS5sZW5ndGgpcmV0dXJuITEKcmV0dXJuIGI9PT1hLnN1YnN0cmluZyhjLHMp
-fSwKbkM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5RaShhLGIsMCl9LApOajpmdW5jdGlvbihhLGIs
-Yyl7aWYoYz09bnVsbCljPWEubGVuZ3RoCmlmKGI8MCl0aHJvdyBILmIoUC5PNyhiLG51bGwpKQppZihi
-PmMpdGhyb3cgSC5iKFAuTzcoYixudWxsKSkKaWYoYz5hLmxlbmd0aCl0aHJvdyBILmIoUC5PNyhjLG51
-bGwpKQpyZXR1cm4gYS5zdWJzdHJpbmcoYixjKX0sCnluOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMu
-TmooYSxiLG51bGwpfSwKaGM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEudG9Mb3dlckNhc2UoKX0sCmJTOmZ1
-bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEudHJpbSgpLG89cC5sZW5ndGgKaWYobz09PTApcmV0dXJuIHAK
-aWYodGhpcy5XKHAsMCk9PT0xMzMpe3M9Si5tbShwLDEpCmlmKHM9PT1vKXJldHVybiIifWVsc2Ugcz0w
-CnI9by0xCnE9dGhpcy5PKHAscik9PT0xMzM/Si5jMShwLHIpOm8KaWYocz09PTAmJnE9PT1vKXJldHVy
-biBwCnJldHVybiBwLnN1YnN0cmluZyhzLHEpfSwKVDpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoMD49
-YilyZXR1cm4iIgppZihiPT09MXx8YS5sZW5ndGg9PT0wKXJldHVybiBhCmlmKGIhPT1iPj4+MCl0aHJv
-dyBILmIoQy5FcSkKZm9yKHM9YSxyPSIiOyEwOyl7aWYoKGImMSk9PT0xKXI9cytyCmI9Yj4+PjEKaWYo
-Yj09PTApYnJlYWsKcys9c31yZXR1cm4gcn0sClhVOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8
-fGM+YS5sZW5ndGgpdGhyb3cgSC5iKFAuVEUoYywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YS5pbmRl
-eE9mKGIsYykKcmV0dXJuIHN9LApPWTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlhVKGEsYiwwKX0s
-ClBrOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCmlmKGM9PW51bGwpYz1hLmxlbmd0aAplbHNlIGlmKGM8
-MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAsYS5sZW5ndGgsbnVsbCxudWxsKSkKcz1iLmxl
-bmd0aApyPWEubGVuZ3RoCmlmKGMrcz5yKWM9ci1zCnJldHVybiBhLmxhc3RJbmRleE9mKGIsYyl9LApj
-bjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlBrKGEsYixudWxsKX0sCklzOmZ1bmN0aW9uKGEsYixj
-KXt2YXIgcz1hLmxlbmd0aAppZihjPnMpdGhyb3cgSC5iKFAuVEUoYywwLHMsbnVsbCxudWxsKSkKcmV0
-dXJuIEguU1EoYSxiLGMpfSwKdGc6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5JcyhhLGIsMCl9LAp3
-OmZ1bmN0aW9uKGEpe3JldHVybiBhfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1hLmxl
-bmd0aCxyPTAscT0wO3E8czsrK3Epe3I9cithLmNoYXJDb2RlQXQocSkmNTM2ODcwOTExCnI9cisoKHIm
-NTI0Mjg3KTw8MTApJjUzNjg3MDkxMQpyXj1yPj42fXI9cisoKHImNjcxMDg4NjMpPDwzKSY1MzY4NzA5
-MTEKcl49cj4+MTEKcmV0dXJuIHIrKChyJjE2MzgzKTw8MTUpJjUzNjg3MDkxMX0sCmdBOmZ1bmN0aW9u
-KGEpe3JldHVybiBhLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+PWEubGVuZ3Ro
-fHwhMSl0aHJvdyBILmIoSC5IWShhLGIpKQpyZXR1cm4gYVtiXX0sCiRpdlg6MSwKJGlxVToxfQpILkJS
-LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILkU3
-KEouSVQodGhpcy5nT04oKSkscy5DKCJAPDE+IikuS3Eocy5RWzFdKS5DKCJFNzwxLDI+IikpfSwKZ0E6
-ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhpcy5nT04oKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJu
-IEoudVUodGhpcy5nT04oKSl9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIEouRjcodGhpcy5nT04oKSl9
-LAplUjpmdW5jdGlvbihhLGIpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIEguR0ooSi5BNSh0aGlzLmdP
-TigpLGIpLHMuYyxzLlFbMV0pfSwKRTpmdW5jdGlvbihhLGIpe3JldHVybiBILkxoKHRoaXMpLlFbMV0u
-YShKLkdBKHRoaXMuZ09OKCksYikpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gSi5qKHRoaXMuZ09OKCkp
-fX0KSC5FNy5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5GKCl9LApnbDpmdW5j
-dGlvbigpe3JldHVybiB0aGlzLiR0aS5RWzFdLmEodGhpcy5hLmdsKCkpfSwKJGlBbjoxfQpILlp5LnBy
-b3RvdHlwZT17CmdPTjpmdW5jdGlvbigpe3JldHVybiB0aGlzLmF9fQpILm9sLnByb3RvdHlwZT17JGli
-UToxfQpILlVxLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy4kdGkuUVsxXS5h
-KEoueDkodGhpcy5hLEgudVAoYikpKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz10aGlzLiR0aQpK
-LnU5KHRoaXMuYSxiLHMuYy5hKHMuUVsxXS5hKGMpKSl9LAokaWJROjEsCiRpek06MX0KSC5qVi5wcm90
-b3R5cGU9ewpkcjpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgSC5qVih0aGlzLmEsdGhpcy4kdGkuQygi
-QDwxPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9LApnT046ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hfX0K
-SC5uLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzIT1udWxsPyJM
-YXRlSW5pdGlhbGl6YXRpb25FcnJvcjogIitzOiJMYXRlSW5pdGlhbGl6YXRpb25FcnJvciJ9fQpILnIz
-LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9IlJlYWNoYWJpbGl0eUVycm9yOiAiK3RoaXMu
-YQpyZXR1cm4gc319CkgucWoucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5s
-ZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEMueEIuTyh0aGlzLmEsSC51UChiKSl9fQpILkdN
-LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk51bGwgaXMgbm90IGEgdmFsaWQgdmFsdWUg
-Zm9yIHRoZSBwYXJhbWV0ZXIgJyIrdGhpcy5hKyInIG9mIHR5cGUgJyIrSC5LeCh0aGlzLiR0aS5jKS53
-KDApKyInIn19CkguYlEucHJvdG90eXBlPXt9CkguYUwucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7
-dmFyIHM9dGhpcwpyZXR1cm4gbmV3IEguYTcocyxzLmdBKHMpLEguTGgocykuQygiYTc8YUwuRT4iKSl9
-LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcyk9PT0wfSwKazpmdW5jdGlvbihhLGIp
-e3ZhciBzLHIscSxwPXRoaXMsbz1wLmdBKHApCmlmKGIubGVuZ3RoIT09MCl7aWYobz09PTApcmV0dXJu
-IiIKcz1ILkVqKHAuRSgwLDApKQppZihvIT09cC5nQShwKSl0aHJvdyBILmIoUC5hNChwKSkKZm9yKHI9
-cyxxPTE7cTxvOysrcSl7cj1yK2IrSC5FaihwLkUoMCxxKSkKaWYobyE9PXAuZ0EocCkpdGhyb3cgSC5i
-KFAuYTQocCkpfXJldHVybiByLmNoYXJDb2RlQXQoMCk9PTA/cjpyfWVsc2V7Zm9yKHE9MCxyPSIiO3E8
-bzsrK3Epe3IrPUguRWoocC5FKDAscSkpCmlmKG8hPT1wLmdBKHApKXRocm93IEguYihQLmE0KHApKX1y
-ZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn19LApldjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlz
-LkdHKDAsSC5MaCh0aGlzKS5DKCJhMihhTC5FKSIpLmEoYikpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILmxKKHRoaXMscy5LcShjKS5DKCIxKGFMLkUpIikuYShi
-KSxzLkMoIkA8YUwuRT4iKS5LcShjKS5DKCJsSjwxLDI+IikpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1
-cm4gSC5xQyh0aGlzLGIsbnVsbCxILkxoKHRoaXMpLkMoImFMLkUiKSl9LAp0dDpmdW5jdGlvbihhLGIp
-e3JldHVybiBQLlkxKHRoaXMsITAsSC5MaCh0aGlzKS5DKCJhTC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7
-cmV0dXJuIHRoaXMudHQoYSwhMCl9fQpILm5ILnByb3RvdHlwZT17CkhkOmZ1bmN0aW9uKGEsYixjLGQp
-e3ZhciBzLHI9dGhpcy5iClAuazEociwic3RhcnQiKQpzPXRoaXMuYwppZihzIT1udWxsKXtQLmsxKHMs
-ImVuZCIpCmlmKHI+cyl0aHJvdyBILmIoUC5URShyLDAscywic3RhcnQiLG51bGwpKX19LApnVUQ6ZnVu
-Y3Rpb24oKXt2YXIgcz1KLkhtKHRoaXMuYSkscj10aGlzLmMKaWYocj09bnVsbHx8cj5zKXJldHVybiBz
-CnJldHVybiByfSwKZ0FzOmZ1bmN0aW9uKCl7dmFyIHM9Si5IbSh0aGlzLmEpLHI9dGhpcy5iCmlmKHI+
-cylyZXR1cm4gcwpyZXR1cm4gcn0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9Si5IbSh0aGlzLmEpLHE9
-dGhpcy5iCmlmKHE+PXIpcmV0dXJuIDAKcz10aGlzLmMKaWYocz09bnVsbHx8cz49cilyZXR1cm4gci1x
-CmlmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIHMuSE4oKQpyZXR1cm4gcy1xfSwKRTpmdW5jdGlv
-bihhLGIpe3ZhciBzPXRoaXMscj1zLmdBcygpK2IKaWYoYjwwfHxyPj1zLmdVRCgpKXRocm93IEguYihQ
-LkNmKGIscywiaW5kZXgiLG51bGwsbnVsbCkpCnJldHVybiBKLkdBKHMuYSxyKX0sCmVSOmZ1bmN0aW9u
-KGEsYil7dmFyIHMscixxPXRoaXMKUC5rMShiLCJjb3VudCIpCnM9cS5iK2IKcj1xLmMKaWYociE9bnVs
-bCYmcz49cilyZXR1cm4gbmV3IEguTUIocS4kdGkuQygiTUI8MT4iKSkKcmV0dXJuIEgucUMocS5hLHMs
-cixxLiR0aS5jKX0sCnR0OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHA9dGhpcyxvPXAuYixuPXAuYSxt
-PUouVTYobiksbD1tLmdBKG4pLGs9cC5jCmlmKGshPW51bGwmJms8bClsPWsKaWYodHlwZW9mIGwhPT0i
-bnVtYmVyIilyZXR1cm4gbC5ITigpCnM9bC1vCmlmKHM8PTApe249Si5RaSgwLHAuJHRpLmMpCnJldHVy
-biBufXI9UC5POChzLG0uRShuLG8pLCExLHAuJHRpLmMpCmZvcihxPTE7cTxzOysrcSl7Qy5ObS5ZNShy
-LHEsbS5FKG4sbytxKSkKaWYobS5nQShuKTxsKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gcn19Ckgu
-YTcucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3Zh
-ciBzLHI9dGhpcyxxPXIuYSxwPUouVTYocSksbz1wLmdBKHEpCmlmKHIuYiE9PW8pdGhyb3cgSC5iKFAu
-YTQocSkpCnM9ci5jCmlmKHM+PW8pe3Iuc0kobnVsbCkKcmV0dXJuITF9ci5zSShwLkUocSxzKSk7Kyty
-LmMKcmV0dXJuITB9LApzSTpmdW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwK
-JGlBbjoxfQpILmkxLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0
-dXJuIG5ldyBILk1IKEouSVQodGhpcy5hKSx0aGlzLmIscy5DKCJAPDE+IikuS3Eocy5RWzFdKS5DKCJN
-SDwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhpcy5hKX0sCmdsMDpmdW5jdGlv
-bihhKXtyZXR1cm4gSi51VSh0aGlzLmEpfSwKRTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmIuJDEo
-Si5HQSh0aGlzLmEsYikpfX0KSC54eS5wcm90b3R5cGU9eyRpYlE6MX0KSC5NSC5wcm90b3R5cGU9ewpG
-OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYgppZihyLkYoKSl7cy5zSShzLmMuJDEoci5nbCgpKSkK
-cmV0dXJuITB9cy5zSShudWxsKQpyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX0s
-CnNJOmZ1bmN0aW9uKGEpe3RoaXMuYT10aGlzLiR0aS5DKCIyPyIpLmEoYSl9fQpILmxKLnByb3RvdHlw
-ZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBKLkhtKHRoaXMuYSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0
-dXJuIHRoaXMuYi4kMShKLkdBKHRoaXMuYSxiKSl9fQpILlU1LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9u
-KGEpe3JldHVybiBuZXcgSC5TTyhKLklUKHRoaXMuYSksdGhpcy5iLHRoaXMuJHRpLkMoIlNPPDE+Iikp
-fX0KSC5TTy5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlz
-LmI7cy5GKCk7KWlmKEgub1Qoci4kMShzLmdsKCkpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0
-aW9uKCl7cmV0dXJuIHRoaXMuYS5nbCgpfX0KSC5BTS5wcm90b3R5cGU9ewplUjpmdW5jdGlvbihhLGIp
-e1AuazEoYiwiY291bnQiKQpyZXR1cm4gbmV3IEguQU0odGhpcy5hLHRoaXMuYitiLEguTGgodGhpcyku
-QygiQU08MT4iKSl9LApnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguVTEoSi5JVCh0aGlzLmEpLHRo
-aXMuYixILkxoKHRoaXMpLkMoIlUxPDE+IikpfX0KSC5kNS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihh
-KXt2YXIgcz1KLkhtKHRoaXMuYSktdGhpcy5iCmlmKHM+PTApcmV0dXJuIHMKcmV0dXJuIDB9LAplUjpm
-dW5jdGlvbihhLGIpe1AuazEoYiwiY291bnQiKQpyZXR1cm4gbmV3IEguZDUodGhpcy5hLHRoaXMuYiti
-LHRoaXMuJHRpKX0sCiRpYlE6MX0KSC5VMS5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpm
-b3Iocz10aGlzLmEscj0wO3I8dGhpcy5iOysrcilzLkYoKQp0aGlzLmI9MApyZXR1cm4gcy5GKCl9LApn
-bDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmEuZ2woKX19CkguTUIucHJvdG90eXBlPXsKZ206ZnVuY3Rp
-b24oYSl7cmV0dXJuIEMuR3d9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuITB9LApnQTpmdW5jdGlvbihh
-KXtyZXR1cm4gMH0sCkU6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5URShiLDAsMCwiaW5kZXgiLG51
-bGwpKX0sCmVSOmZ1bmN0aW9uKGEsYil7UC5rMShiLCJjb3VudCIpCnJldHVybiB0aGlzfX0KSC5GdS5w
-cm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7cmV0dXJuITF9LApnbDpmdW5jdGlvbigpe3Rocm93IEguYihI
-LldwKCkpfSwKJGlBbjoxfQpILnU2LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcg
-SC5KQihKLklUKHRoaXMuYSksdGhpcy4kdGkuQygiSkI8MT4iKSl9fQpILkpCLnByb3RvdHlwZT17CkY6
-ZnVuY3Rpb24oKXt2YXIgcyxyCmZvcihzPXRoaXMuYSxyPXRoaXMuJHRpLmM7cy5GKCk7KWlmKHIuYihz
-LmdsKCkpKXJldHVybiEwCnJldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy4kdGkuYy5h
-KHRoaXMuYS5nbCgpKX0sCiRpQW46MX0KSC5TVS5wcm90b3R5cGU9e30KSC5SZS5wcm90b3R5cGU9ewpZ
-NTpmdW5jdGlvbihhLGIsYyl7SC5MaCh0aGlzKS5DKCJSZS5FIikuYShjKQp0aHJvdyBILmIoUC5MNCgi
-Q2Fubm90IG1vZGlmeSBhbiB1bm1vZGlmaWFibGUgbGlzdCIpKX19CkgudzIucHJvdG90eXBlPXt9Ckgu
-d3YucHJvdG90eXBlPXsKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuX2hhc2hDb2RlCmlmKHMhPW51
-bGwpcmV0dXJuIHMKcz02NjQ1OTcqSi5oZih0aGlzLmEpJjUzNjg3MDkxMQp0aGlzLl9oYXNoQ29kZT1z
-CnJldHVybiBzfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4nU3ltYm9sKCInK0guRWoodGhpcy5hKSsnIikn
-fSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJldHVybiExCnJldHVybiBiIGluc3RhbmNlb2Yg
-SC53diYmdGhpcy5hPT1iLmF9LAokaUdEOjF9CkguUUMucHJvdG90eXBlPXt9CkguUEQucHJvdG90eXBl
-PXt9CkguV1UucHJvdG90eXBlPXsKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpPT09
-MH0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFAubk8odGhpcyl9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFy
-IHM9SC5MaCh0aGlzKQpzLmMuYShiKQpzLlFbMV0uYShjKQpILmRjKCkKSC5CaSh1LmcpfSwKZ1B1OmZ1
-bmN0aW9uKGEpe3JldHVybiB0aGlzLnE0KDAsSC5MaCh0aGlzKS5DKCJOMzwxLDI+IikpfSwKcTQ6ZnVu
-Y3Rpb24oYSxiKXt2YXIgcz10aGlzCnJldHVybiBQLmwwKGZ1bmN0aW9uKCl7dmFyIHI9YQp2YXIgcT0w
-LHA9MSxvLG4sbSxsLGsKcmV0dXJuIGZ1bmN0aW9uICRhc3luYyRnUHUoYyxkKXtpZihjPT09MSl7bz1k
-CnE9cH13aGlsZSh0cnVlKXN3aXRjaChxKXtjYXNlIDA6bj1zLmd2YygpLG49bi5nbShuKSxtPUguTGgo
-cyksbT1tLkMoIkA8MT4iKS5LcShtLlFbMV0pLkMoIk4zPDEsMj4iKQpjYXNlIDI6aWYoIW4uRigpKXtx
-PTMKYnJlYWt9bD1uLmdsKCkKaz1zLnEoMCxsKQprLnRvU3RyaW5nCnE9NApyZXR1cm4gbmV3IFAuTjMo
-bCxrLG0pCmNhc2UgNDpxPTIKYnJlYWsKY2FzZSAzOnJldHVybiBQLlRoKCkKY2FzZSAxOnJldHVybiBQ
-LlltKG8pfX19LGIpfSwKJGlaMDoxfQpILkxQLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVy
-biB0aGlzLmF9LAp4NDpmdW5jdGlvbihhKXtpZih0eXBlb2YgYSE9InN0cmluZyIpcmV0dXJuITEKaWYo
-Il9fcHJvdG9fXyI9PT1hKXJldHVybiExCnJldHVybiB0aGlzLmIuaGFzT3duUHJvcGVydHkoYSl9LApx
-OmZ1bmN0aW9uKGEsYil7aWYoIXRoaXMueDQoYikpcmV0dXJuIG51bGwKcmV0dXJuIHRoaXMucVAoYil9
-LApxUDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5iW0guaChhKV19LApLOmZ1bmN0aW9uKGEsYil7dmFy
-IHMscixxLHAsbz1ILkxoKHRoaXMpCm8uQygifigxLDIpIikuYShiKQpzPXRoaXMuYwpmb3Iocj1zLmxl
-bmd0aCxvPW8uUVsxXSxxPTA7cTxyOysrcSl7cD1zW3FdCmIuJDIocCxvLmEodGhpcy5xUChwKSkpfX0s
-Cmd2YzpmdW5jdGlvbigpe3JldHVybiBuZXcgSC5YUih0aGlzLEguTGgodGhpcykuQygiWFI8MT4iKSl9
-fQpILlhSLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5jCnJldHVybiBuZXcg
-Si5tMShzLHMubGVuZ3RoLEgudDYocykuQygibTE8MT4iKSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4g
-dGhpcy5hLmMubGVuZ3RofX0KSC5MSS5wcm90b3R5cGU9ewpnV2E6ZnVuY3Rpb24oKXt2YXIgcz10aGlz
-LmEKcmV0dXJuIHN9LApnbmQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMKaWYoby5jPT09MSly
-ZXR1cm4gQy5oVQpzPW8uZApyPXMubGVuZ3RoLW8uZS5sZW5ndGgtby5mCmlmKHI9PT0wKXJldHVybiBD
-LmhVCnE9W10KZm9yKHA9MDtwPHI7KytwKXtpZihwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLHApCnEu
-cHVzaChzW3BdKX1yZXR1cm4gSi56QyhxKX0sCmdWbTpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixt
-LGwsaz10aGlzCmlmKGsuYyE9PTApcmV0dXJuIEMuV08Kcz1rLmUKcj1zLmxlbmd0aApxPWsuZApwPXEu
-bGVuZ3RoLXItay5mCmlmKHI9PT0wKXJldHVybiBDLldPCm89bmV3IEguTjUodC5lbykKZm9yKG49MDtu
-PHI7KytuKXtpZihuPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLG4pCm09c1tuXQpsPXArbgppZihsPDB8
-fGw+PXEubGVuZ3RoKXJldHVybiBILk9IKHEsbCkKby5ZNSgwLG5ldyBILnd2KG0pLHFbbF0pfXJldHVy
-biBuZXcgSC5QRChvLHQuZ0YpfSwKJGl2UToxfQpILkNqLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEs
-Yil7dmFyIHMKSC5oKGEpCnM9dGhpcy5hCnMuYj1zLmIrIiQiK0guRWooYSkKQy5ObS5pKHRoaXMuYixh
-KQpDLk5tLmkodGhpcy5jLGIpOysrcy5hfSwKJFM6MTN9CkguZjkucHJvdG90eXBlPXsKcVM6ZnVuY3Rp
-b24oYSl7dmFyIHMscixxPXRoaXMscD1uZXcgUmVnRXhwKHEuYSkuZXhlYyhhKQppZihwPT1udWxsKXJl
-dHVybiBudWxsCnM9T2JqZWN0LmNyZWF0ZShudWxsKQpyPXEuYgppZihyIT09LTEpcy5hcmd1bWVudHM9
-cFtyKzFdCnI9cS5jCmlmKHIhPT0tMSlzLmFyZ3VtZW50c0V4cHI9cFtyKzFdCnI9cS5kCmlmKHIhPT0t
-MSlzLmV4cHI9cFtyKzFdCnI9cS5lCmlmKHIhPT0tMSlzLm1ldGhvZD1wW3IrMV0Kcj1xLmYKaWYociE9
-PS0xKXMucmVjZWl2ZXI9cFtyKzFdCnJldHVybiBzfX0KSC5XMC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9u
-KGEpe3ZhciBzPXRoaXMuYgppZihzPT1udWxsKXJldHVybiJOb1N1Y2hNZXRob2RFcnJvcjogIitILkVq
-KHRoaXMuYSkKcmV0dXJuIk5vU3VjaE1ldGhvZEVycm9yOiBtZXRob2Qgbm90IGZvdW5kOiAnIitzKyIn
-IG9uIG51bGwifX0KSC5hei5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcyxxPSJO
-b1N1Y2hNZXRob2RFcnJvcjogbWV0aG9kIG5vdCBmb3VuZDogJyIscD1yLmIKaWYocD09bnVsbClyZXR1
-cm4iTm9TdWNoTWV0aG9kRXJyb3I6ICIrSC5FaihyLmEpCnM9ci5jCmlmKHM9PW51bGwpcmV0dXJuIHEr
-cCsiJyAoIitILkVqKHIuYSkrIikiCnJldHVybiBxK3ArIicgb24gJyIrcysiJyAoIitILkVqKHIuYSkr
-IikifX0KSC52Vi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5s
-ZW5ndGg9PT0wPyJFcnJvciI6IkVycm9yOiAiK3N9fQpILnRlLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
-YSl7cmV0dXJuIlRocm93IG9mIG51bGwgKCciKyh0aGlzLmE9PT1udWxsPyJudWxsIjoidW5kZWZpbmVk
-IikrIicgZnJvbSBKYXZhU2NyaXB0KSJ9LAokaVJ6OjF9CkguYnEucHJvdG90eXBlPXt9CkguWE8ucHJv
-dG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuYgppZihyIT1udWxsKXJldHVybiByCnI9
-dGhpcy5hCnM9ciE9PW51bGwmJnR5cGVvZiByPT09Im9iamVjdCI/ci5zdGFjazpudWxsCnJldHVybiB0
-aGlzLmI9cz09bnVsbD8iIjpzfSwKJGlHejoxfQpILlRwLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7
-dmFyIHM9dGhpcy5jb25zdHJ1Y3RvcixyPXM9PW51bGw/bnVsbDpzLm5hbWUKcmV0dXJuIkNsb3N1cmUg
-JyIrSC5OUShyPT1udWxsPyJ1bmtub3duIjpyKSsiJyJ9LAokaUVIOjEsCmdLdTpmdW5jdGlvbigpe3Jl
-dHVybiB0aGlzfSwKJEM6IiQxIiwKJFI6MSwKJEQ6bnVsbH0KSC5sYy5wcm90b3R5cGU9e30KSC56eC5w
-cm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuJHN0YXRpY19uYW1lCmlmKHM9PW51bGwp
-cmV0dXJuIkNsb3N1cmUgb2YgdW5rbm93biBzdGF0aWMgbWV0aG9kIgpyZXR1cm4iQ2xvc3VyZSAnIitI
-Lk5RKHMpKyInIn19CkguclQucHJvdG90eXBlPXsKRE46ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzCmlm
-KGI9PW51bGwpcmV0dXJuITEKaWYocz09PWIpcmV0dXJuITAKaWYoIShiIGluc3RhbmNlb2YgSC5yVCkp
-cmV0dXJuITEKcmV0dXJuIHMuYT09PWIuYSYmcy5iPT09Yi5iJiZzLmM9PT1iLmN9LApnaU86ZnVuY3Rp
-b24oYSl7dmFyIHMscj10aGlzLmMKaWYocj09bnVsbClzPUguZVEodGhpcy5hKQplbHNlIHM9dHlwZW9m
-IHIhPT0ib2JqZWN0Ij9KLmhmKHIpOkguZVEocikKcj1ILmVRKHRoaXMuYikKaWYodHlwZW9mIHMhPT0i
-bnVtYmVyIilyZXR1cm4gcy5ZKCkKcmV0dXJuKHNecik+Pj4wfSwKdzpmdW5jdGlvbihhKXt2YXIgcz10
-aGlzLmMKaWYocz09bnVsbClzPXRoaXMuYQpyZXR1cm4iQ2xvc3VyZSAnIitILkVqKHRoaXMuZCkrIicg
-b2YgIisoIkluc3RhbmNlIG9mICciK0guRWooSC5NKHMpKSsiJyIpfX0KSC5FcS5wcm90b3R5cGU9ewp3
-OmZ1bmN0aW9uKGEpe3JldHVybiJSdW50aW1lRXJyb3I6ICIrdGhpcy5hfX0KSC5rWS5wcm90b3R5cGU9
-ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJBc3NlcnRpb24gZmFpbGVkOiAiK1AucCh0aGlzLmEpfX0KSC5r
-ci5wcm90b3R5cGU9e30KSC5ONS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5h
-fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmE9PT0wfSwKZ3ZjOmZ1bmN0aW9uKCl7cmV0dXJu
-IG5ldyBILmk1KHRoaXMsSC5MaCh0aGlzKS5DKCJpNTwxPiIpKX0sCng0OmZ1bmN0aW9uKGEpe3ZhciBz
-LHIKaWYodHlwZW9mIGE9PSJzdHJpbmciKXtzPXRoaXMuYgppZihzPT1udWxsKXJldHVybiExCnJldHVy
-biB0aGlzLlh1KHMsYSl9ZWxzZXtyPXRoaXMuQ1goYSkKcmV0dXJuIHJ9fSwKQ1g6ZnVuY3Rpb24oYSl7
-dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJuITEKcmV0dXJuIHRoaXMuRmgodGhpcy5CdChzLEou
-aGYoYSkmMHgzZmZmZmZmKSxhKT49MH0sCnE6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvPXRoaXMs
-bj1udWxsCmlmKHR5cGVvZiBiPT0ic3RyaW5nIil7cz1vLmIKaWYocz09bnVsbClyZXR1cm4gbgpyPW8u
-ajIocyxiKQpxPXI9PW51bGw/bjpyLmIKcmV0dXJuIHF9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJlciIm
-JihiJjB4M2ZmZmZmZik9PT1iKXtwPW8uYwppZihwPT1udWxsKXJldHVybiBuCnI9by5qMihwLGIpCnE9
-cj09bnVsbD9uOnIuYgpyZXR1cm4gcX1lbHNlIHJldHVybiBvLmFhKGIpfSwKYWE6ZnVuY3Rpb24oYSl7
-dmFyIHMscixxPXRoaXMuZAppZihxPT1udWxsKXJldHVybiBudWxsCnM9dGhpcy5CdChxLEouaGYoYSkm
-MHgzZmZmZmZmKQpyPXRoaXMuRmgocyxhKQppZihyPDApcmV0dXJuIG51bGwKcmV0dXJuIHNbcl0uYn0s
-Clk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9SC5MaChtKQpsLmMuYShi
-KQpsLlFbMV0uYShjKQppZih0eXBlb2YgYj09InN0cmluZyIpe3M9bS5iCm0uRUgocz09bnVsbD9tLmI9
-bS56SygpOnMsYixjKX1lbHNlIGlmKHR5cGVvZiBiPT0ibnVtYmVyIiYmKGImMHgzZmZmZmZmKT09PWIp
-e3I9bS5jCm0uRUgocj09bnVsbD9tLmM9bS56SygpOnIsYixjKX1lbHNle3E9bS5kCmlmKHE9PW51bGwp
-cT1tLmQ9bS56SygpCnA9Si5oZihiKSYweDNmZmZmZmYKbz1tLkJ0KHEscCkKaWYobz09bnVsbCltLkVJ
-KHEscCxbbS5IbihiLGMpXSkKZWxzZXtuPW0uRmgobyxiKQppZihuPj0wKW9bbl0uYj1jCmVsc2Ugby5w
-dXNoKG0uSG4oYixjKSl9fX0sCks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9dGhpcwpILkxoKHEpLkMo
-In4oMSwyKSIpLmEoYikKcz1xLmUKcj1xLnIKZm9yKDtzIT1udWxsOyl7Yi4kMihzLmEscy5iKQppZihy
-IT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXMuY319LApFSDpmdW5jdGlvbihhLGIsYyl7dmFyIHMs
-cj10aGlzLHE9SC5MaChyKQpxLmMuYShiKQpxLlFbMV0uYShjKQpzPXIuajIoYSxiKQppZihzPT1udWxs
-KXIuRUkoYSxiLHIuSG4oYixjKSkKZWxzZSBzLmI9Y30sCmtzOmZ1bmN0aW9uKCl7dGhpcy5yPXRoaXMu
-cisxJjY3MTA4ODYzfSwKSG46ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLHI9SC5MaChzKSxxPW5ldyBI
-LnZoKHIuYy5hKGEpLHIuUVsxXS5hKGIpKQppZihzLmU9PW51bGwpcy5lPXMuZj1xCmVsc2V7cj1zLmYK
-ci50b1N0cmluZwpxLmQ9cgpzLmY9ci5jPXF9KytzLmEKcy5rcygpCnJldHVybiBxfSwKRmg6ZnVuY3Rp
-b24oYSxiKXt2YXIgcyxyCmlmKGE9PW51bGwpcmV0dXJuLTEKcz1hLmxlbmd0aApmb3Iocj0wO3I8czsr
-K3IpaWYoSi5STShhW3JdLmEsYikpcmV0dXJuIHIKcmV0dXJuLTF9LAp3OmZ1bmN0aW9uKGEpe3JldHVy
-biBQLm5PKHRoaXMpfSwKajI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYVtiXX0sCkJ0OmZ1bmN0aW9uKGEs
-Yil7cmV0dXJuIGFbYl19LApFSTpmdW5jdGlvbihhLGIsYyl7YVtiXT1jfSwKcm46ZnVuY3Rpb24oYSxi
-KXtkZWxldGUgYVtiXX0sClh1OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuajIoYSxiKSE9bnVsbH0s
-CnpLOmZ1bmN0aW9uKCl7dmFyIHM9Ijxub24taWRlbnRpZmllci1rZXk+IixyPU9iamVjdC5jcmVhdGUo
-bnVsbCkKdGhpcy5FSShyLHMscikKdGhpcy5ybihyLHMpCnJldHVybiByfSwKJGlGbzoxfQpILnZoLnBy
-b3RvdHlwZT17fQpILmk1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuYX0s
-CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmE9PT0wfSwKZ206ZnVuY3Rpb24oYSl7dmFyIHM9
-dGhpcy5hLHI9bmV3IEguTjYocyxzLnIsdGhpcy4kdGkuQygiTjY8MT4iKSkKci5jPXMuZQpyZXR1cm4g
-cn0sCnRnOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS54NChiKX19CkguTjYucHJvdG90eXBlPXsK
-Z2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIu
-YQppZihyLmIhPT1xLnIpdGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM9PW51bGwpe3Iuc3FZKG51
-bGwpCnJldHVybiExfWVsc2V7ci5zcVkocy5hKQpyLmM9cy5jCnJldHVybiEwfX0sCnNxWTpmdW5jdGlv
-bihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpILmRDLnByb3RvdHlwZT17
-CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEoYSl9LAokUzo0fQpILndOLnByb3RvdHlwZT17CiQy
-OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYShhLGIpfSwKJFM6MzR9CkguVlgucHJvdG90eXBlPXsK
-JDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYShILmgoYSkpfSwKJFM6MzJ9CkguVlIucHJvdG90eXBl
-PXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iUmVnRXhwLyIrdGhpcy5hKyIvIit0aGlzLmIuZmxhZ3N9LApn
-SGM6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5jCmlmKHIhPW51bGwpcmV0dXJuIHIKcj1zLmIKcmV0
-dXJuIHMuYz1ILnY0KHMuYSxyLm11bHRpbGluZSwhci5pZ25vcmVDYXNlLHIudW5pY29kZSxyLmRvdEFs
-bCwhMCl9LApkZDpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgSC5LVyh0aGlzLGIsMCl9LApVWjpmdW5j
-dGlvbihhLGIpe3ZhciBzLHI9dGhpcy5nSGMoKQpyLmxhc3RJbmRleD1iCnM9ci5leGVjKGEpCmlmKHM9
-PW51bGwpcmV0dXJuIG51bGwKcmV0dXJuIG5ldyBILkVLKHMpfSwKJGl2WDoxLAokaXdMOjF9CkguRUsu
-cHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3ZhciBzCkgudVAoYikKcz10aGlzLmIKaWYoYj49cy5s
-ZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1cm4gc1tiXX0sCiRpT2Q6MSwKJGlpYjoxfQpILktXLnBy
-b3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5QYih0aGlzLmEsdGhpcy5iLHRoaXMu
-Yyl9fQpILlBiLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rp
-b24oKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9bS5iCmlmKGw9PW51bGwpcmV0dXJuITEKcz1tLmMK
-cj1sLmxlbmd0aAppZihzPD1yKXtxPW0uYQpwPXEuVVoobCxzKQppZihwIT1udWxsKXttLmQ9cApzPXAu
-YgpvPXMuaW5kZXgKbj1vK3NbMF0ubGVuZ3RoCmlmKG89PT1uKXtpZihxLmIudW5pY29kZSl7cz1tLmMK
-cT1zKzEKaWYocTxyKXtzPUMueEIuTyhsLHMpCmlmKHM+PTU1Mjk2JiZzPD01NjMxOSl7cz1DLnhCLk8o
-bCxxKQpzPXM+PTU2MzIwJiZzPD01NzM0M31lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMQpuPShz
-P24rMTpuKSsxfW0uYz1uCnJldHVybiEwfX1tLmI9bS5kPW51bGwKcmV0dXJuITF9LAokaUFuOjF9Ckgu
-dFEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYiE9PTApSC52KFAuTzcoYixu
-dWxsKSkKcmV0dXJuIHRoaXMuY30sCiRpT2Q6MX0KSC51bi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihh
-KXtyZXR1cm4gbmV3IEguU2QodGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5TZC5wcm90b3R5cGU9ewpG
-OmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMscD1xLmMsbz1xLmIsbj1vLmxlbmd0aCxtPXEuYSxsPW0u
-bGVuZ3RoCmlmKHArbj5sKXtxLmQ9bnVsbApyZXR1cm4hMX1zPW0uaW5kZXhPZihvLHApCmlmKHM8MCl7
-cS5jPWwrMQpxLmQ9bnVsbApyZXR1cm4hMX1yPXMrbgpxLmQ9bmV3IEgudFEocyxvKQpxLmM9cj09PXEu
-Yz9yKzE6cgpyZXR1cm4hMH0sCmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5kCnMudG9TdHJpbmcKcmV0
-dXJuIHN9LAokaUFuOjF9CkguRVQucHJvdG90eXBlPXskaUVUOjEsJGlBUzoxfQpILkxaLnByb3RvdHlw
-ZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCiRpWGo6MX0KSC5EZy5wcm90b3R5cGU9
-ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LApZ
-NTpmdW5jdGlvbihhLGIsYyl7SC5HSChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUTox
-LAokaWNYOjEsCiRpek06MX0KSC5QZy5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7SC51UChj
-KQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0KSC54ai5w
-cm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJu
-IGFbYl19fQpILmRFLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEu
-bGVuZ3RoKQpyZXR1cm4gYVtiXX19CkguWkEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAo
-YikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kVC5wcm90b3R5cGU9ewpxOmZ1bmN0
-aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILlBxLnByb3Rv
-dHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVti
-XX19CkguZUUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5j
-dGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5WNi5wcm90
-b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7SC51
-UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LAokaVY2OjEsCiRpbjY6MX0KSC5SRy5w
-cm90b3R5cGU9e30KSC5WUC5wcm90b3R5cGU9e30KSC5XQi5wcm90b3R5cGU9e30KSC5aRy5wcm90b3R5
-cGU9e30KSC5KYy5wcm90b3R5cGU9ewpDOmZ1bmN0aW9uKGEpe3JldHVybiBILmNFKHYudHlwZVVuaXZl
-cnNlLHRoaXMsYSl9LApLcTpmdW5jdGlvbihhKXtyZXR1cm4gSC52NSh2LnR5cGVVbml2ZXJzZSx0aGlz
-LGEpfX0KSC5HLnByb3RvdHlwZT17fQpILmxZLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJu
-IEguZG0odGhpcy5hLG51bGwpfX0KSC5rUy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0
-aGlzLmF9fQpILmlNLnByb3RvdHlwZT17fQpQLnRoLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Zh
-ciBzPXRoaXMuYSxyPXMuYQpzLmE9bnVsbApyLiQwKCl9LAokUzoxMH0KUC5oYS5wcm90b3R5cGU9ewok
-MTpmdW5jdGlvbihhKXt2YXIgcyxyCnRoaXMuYS5hPXQuTS5hKGEpCnM9dGhpcy5iCnI9dGhpcy5jCnMu
-Zmlyc3RDaGlsZD9zLnJlbW92ZUNoaWxkKHIpOnMuYXBwZW5kQ2hpbGQocil9LAokUzo1M30KUC5Wcy5w
-cm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS4kMCgpfSwKJEM6IiQwIiwKJFI6MCwKJFM6Mn0K
-UC5GdC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS4kMCgpfSwKJEM6IiQwIiwKJFI6MCwK
-JFM6Mn0KUC5XMy5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhLGIpe2lmKHNlbGYuc2V0VGltZW91dCE9
-bnVsbClzZWxmLnNldFRpbWVvdXQoSC50UihuZXcgUC55SCh0aGlzLGIpLDApLGEpCmVsc2UgdGhyb3cg
-SC5iKFAuTDQoImBzZXRUaW1lb3V0KClgIG5vdCBmb3VuZC4iKSl9fQpQLnlILnByb3RvdHlwZT17CiQw
-OmZ1bmN0aW9uKCl7dGhpcy5iLiQwKCl9LAokQzoiJDAiLAokUjowLAokUzowfQpQLmloLnByb3RvdHlw
-ZT17CmFNOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLHE9ci4kdGkKcS5DKCIxLz8iKS5hKGIpCmlm
-KCFyLmIpci5hLlhmKGIpCmVsc2V7cz1yLmEKaWYocS5DKCJiODwxPiIpLmIoYikpcy5jVShiKQplbHNl
-IHMuWDIocS5jLmEoYikpfX0sCncwOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYj09bnVsbCliPVAudjAo
-YSkKcz10aGlzLmEKaWYodGhpcy5iKXMuWkwoYSxiKQplbHNlIHMuTmsoYSxiKX19ClAuV00ucHJvdG90
-eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMigwLGEpfSwKJFM6NDN9ClAuU1gucHJv
-dG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuJDIoMSxuZXcgSC5icShhLHQubC5hKGIpKSl9
-LAokQzoiJDIiLAokUjoyLAokUzo1NX0KUC5Hcy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3Ro
-aXMuYShILnVQKGEpLGIpfSwKJFM6MjR9ClAuRnkucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1
-cm4iSXRlcmF0aW9uTWFya2VyKCIrdGhpcy5iKyIsICIrSC5Faih0aGlzLmEpKyIpIn19ClAuR1YucHJv
-dG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLmMKaWYocz09bnVsbClyZXR1cm4gdGhpcy4k
-dGkuYy5hKHRoaXMuYikKcmV0dXJuIHMuZ2woKX0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4s
-bT10aGlzCmZvcihzPW0uJHRpLkMoIkFuPDE+Iik7ITA7KXtyPW0uYwppZihyIT1udWxsKWlmKHIuRigp
-KXJldHVybiEwCmVsc2UgbS5zWDkobnVsbCkKcT1mdW5jdGlvbihhLGIsYyl7dmFyIGwsaz1iCndoaWxl
-KHRydWUpdHJ5e3JldHVybiBhKGssbCl9Y2F0Y2goail7bD1qCms9Y319KG0uYSwwLDEpCmlmKHEgaW5z
-dGFuY2VvZiBQLkZ5KXtwPXEuYgppZihwPT09Mil7bz1tLmQKaWYobz09bnVsbHx8by5sZW5ndGg9PT0w
-KXttLnNFQyhudWxsKQpyZXR1cm4hMX1pZigwPj1vLmxlbmd0aClyZXR1cm4gSC5PSChvLC0xKQptLmE9
-by5wb3AoKQpjb250aW51ZX1lbHNle3I9cS5hCmlmKHA9PT0zKXRocm93IHIKZWxzZXtuPXMuYShKLklU
-KHIpKQppZihuIGluc3RhbmNlb2YgUC5HVil7cj1tLmQKaWYocj09bnVsbClyPW0uZD1bXQpDLk5tLmko
-cixtLmEpCm0uYT1uLmEKY29udGludWV9ZWxzZXttLnNYOShuKQpjb250aW51ZX19fX1lbHNle20uc0VD
-KHEpCnJldHVybiEwfX1yZXR1cm4hMX0sCnNFQzpmdW5jdGlvbihhKXt0aGlzLmI9dGhpcy4kdGkuQygi
-MT8iKS5hKGEpfSwKc1g5OmZ1bmN0aW9uKGEpe3RoaXMuYz10aGlzLiR0aS5DKCJBbjwxPj8iKS5hKGEp
-fSwKJGlBbjoxfQpQLnE0LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5HVih0
-aGlzLmEoKSx0aGlzLiR0aS5DKCJHVjwxPiIpKX19ClAuQ3cucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
-KXtyZXR1cm4gSC5Faih0aGlzLmEpfSwKJGlYUzoxLApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5i
-fX0KUC5QZi5wcm90b3R5cGU9ewp3MDpmdW5jdGlvbihhLGIpe3ZhciBzCkguY2IoYSwiZXJyb3IiLHQu
-SykKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBILmIoUC5QVigiRnV0dXJlIGFscmVhZHkgY29tcGxl
-dGVkIikpCmlmKGI9PW51bGwpYj1QLnYwKGEpCnMuTmsoYSxiKX0sCnBtOmZ1bmN0aW9uKGEpe3JldHVy
-biB0aGlzLncwKGEsbnVsbCl9fQpQLlpmLnByb3RvdHlwZT17CmFNOmZ1bmN0aW9uKGEsYil7dmFyIHMs
-cj10aGlzLiR0aQpyLkMoIjEvPyIpLmEoYikKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBILmIoUC5Q
-VigiRnV0dXJlIGFscmVhZHkgY29tcGxldGVkIikpCnMuWGYoci5DKCIxLyIpLmEoYikpfX0KUC5GZS5w
-cm90b3R5cGU9ewpIUjpmdW5jdGlvbihhKXtpZigodGhpcy5jJjE1KSE9PTYpcmV0dXJuITAKcmV0dXJu
-IHRoaXMuYi5iLmJ2KHQuYWwuYSh0aGlzLmQpLGEuYSx0LnksdC5LKX0sCkt3OmZ1bmN0aW9uKGEpe3Zh
-ciBzPXRoaXMuZSxyPXQueixxPXQuSyxwPXRoaXMuJHRpLkMoIjIvIiksbz10aGlzLmIuYgppZih0LmFn
-LmIocykpcmV0dXJuIHAuYShvLnJwKHMsYS5hLGEuYixyLHEsdC5sKSkKZWxzZSByZXR1cm4gcC5hKG8u
-YnYodC5iSS5hKHMpLGEuYSxyLHEpKX19ClAudnMucHJvdG90eXBlPXsKU3E6ZnVuY3Rpb24oYSxiLGMp
-e3ZhciBzLHIscSxwPXRoaXMuJHRpCnAuS3EoYykuQygiMS8oMikiKS5hKGEpCnM9JC5YMwppZihzIT09
-Qy5OVSl7Yy5DKCJAPDAvPiIpLktxKHAuYykuQygiMSgyKSIpLmEoYSkKaWYoYiE9bnVsbCliPVAuVkgo
-YixzKX1yPW5ldyBQLnZzKHMsYy5DKCJ2czwwPiIpKQpxPWI9PW51bGw/MTozCnRoaXMueGYobmV3IFAu
-RmUocixxLGEsYixwLkMoIkA8MT4iKS5LcShjKS5DKCJGZTwxLDI+IikpKQpyZXR1cm4gcn0sClc3OmZ1
-bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuU3EoYSxudWxsLGIpfSwKUWQ6ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBzLHI9dGhpcy4kdGkKci5LcShjKS5DKCIxLygyKSIpLmEoYSkKcz1uZXcgUC52cygkLlgzLGMuQygi
-dnM8MD4iKSkKdGhpcy54ZihuZXcgUC5GZShzLDE5LGEsYixyLkMoIkA8MT4iKS5LcShjKS5DKCJGZTwx
-LDI+IikpKQpyZXR1cm4gc30sCnhmOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcyxxPXIuYQppZihxPD0x
-KXthLmE9dC5GLmEoci5jKQpyLmM9YX1lbHNle2lmKHE9PT0yKXtzPXQuYy5hKHIuYykKcT1zLmEKaWYo
-cTw0KXtzLnhmKGEpCnJldHVybn1yLmE9cQpyLmM9cy5jfVAuVGsobnVsbCxudWxsLHIuYix0Lk0uYShu
-ZXcgUC5kYShyLGEpKSl9fSwKalE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPXt9
-CmwuYT1hCmlmKGE9PW51bGwpcmV0dXJuCnM9bS5hCmlmKHM8PTEpe3I9dC5GLmEobS5jKQptLmM9YQpp
-ZihyIT1udWxsKXtxPWEuYQpmb3IocD1hO3EhPW51bGw7cD1xLHE9bylvPXEuYQpwLmE9cn19ZWxzZXtp
-ZihzPT09Mil7bj10LmMuYShtLmMpCnM9bi5hCmlmKHM8NCl7bi5qUShhKQpyZXR1cm59bS5hPXMKbS5j
-PW4uY31sLmE9bS5OOChhKQpQLlRrKG51bGwsbnVsbCxtLmIsdC5NLmEobmV3IFAub1EobCxtKSkpfX0s
-CmFoOmZ1bmN0aW9uKCl7dmFyIHM9dC5GLmEodGhpcy5jKQp0aGlzLmM9bnVsbApyZXR1cm4gdGhpcy5O
-OChzKX0sCk44OmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1hLHI9bnVsbDtzIT1udWxsO3I9cyxz
-PXEpe3E9cy5hCnMuYT1yfXJldHVybiByfSwKZWM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9dGhpcwpw
-LmE9MQp0cnl7YS5TcShuZXcgUC5wVihwKSxuZXcgUC5VNyhwKSx0LlApfWNhdGNoKHEpe3M9SC5SdShx
-KQpyPUgudHMocSkKUC5yYihuZXcgUC52cihwLHMscikpfX0sClgyOmZ1bmN0aW9uKGEpe3ZhciBzLHI9
-dGhpcwpyLiR0aS5jLmEoYSkKcz1yLmFoKCkKci5hPTQKci5jPWEKUC5IWihyLHMpfSwKWkw6ZnVuY3Rp
-b24oYSxiKXt2YXIgcyxyLHE9dGhpcwp0LmwuYShiKQpzPXEuYWgoKQpyPVAuVGwoYSxiKQpxLmE9OApx
-LmM9cgpQLkhaKHEscyl9LApYZjpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiR0aQpzLkMoIjEvIikuYShh
-KQppZihzLkMoImI4PDE+IikuYihhKSl7dGhpcy5jVShhKQpyZXR1cm59dGhpcy53VShzLmMuYShhKSl9
-LAp3VTpmdW5jdGlvbihhKXt2YXIgcz10aGlzCnMuJHRpLmMuYShhKQpzLmE9MQpQLlRrKG51bGwsbnVs
-bCxzLmIsdC5NLmEobmV3IFAucnQocyxhKSkpfSwKY1U6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPXMu
-JHRpCnIuQygiYjg8MT4iKS5hKGEpCmlmKHIuYihhKSl7aWYoYS5hPT09OCl7cy5hPTEKUC5UayhudWxs
-LG51bGwscy5iLHQuTS5hKG5ldyBQLktGKHMsYSkpKX1lbHNlIFAuQTkoYSxzKQpyZXR1cm59cy5lYyhh
-KX0sCk5rOmZ1bmN0aW9uKGEsYil7dGhpcy5hPTEKUC5UayhudWxsLG51bGwsdGhpcy5iLHQuTS5hKG5l
-dyBQLlpMKHRoaXMsYSxiKSkpfSwKJGliODoxfQpQLmRhLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7
-UC5IWih0aGlzLmEsdGhpcy5iKX0sCiRTOjB9ClAub1EucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtQ
-LkhaKHRoaXMuYix0aGlzLmEuYSl9LAokUzowfQpQLnBWLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
-e3ZhciBzLHIscSxwPXRoaXMuYQpwLmE9MAp0cnl7cC5YMihwLiR0aS5jLmEoYSkpfWNhdGNoKHEpe3M9
-SC5SdShxKQpyPUgudHMocSkKcC5aTChzLHIpfX0sCiRTOjEwfQpQLlU3LnByb3RvdHlwZT17CiQyOmZ1
-bmN0aW9uKGEsYil7dGhpcy5hLlpMKGEsdC5sLmEoYikpfSwKJEM6IiQyIiwKJFI6MiwKJFM6Mjh9ClAu
-dnIucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuWkwodGhpcy5iLHRoaXMuYyl9LAokUzow
-fQpQLnJ0LnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlgyKHRoaXMuYil9LAokUzowfQpQ
-LktGLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7UC5BOSh0aGlzLmIsdGhpcy5hKX0sCiRTOjB9ClAu
-WkwucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuWkwodGhpcy5iLHRoaXMuYyl9LAokUzow
-fQpQLlJULnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPW51
-bGwKdHJ5e3E9bS5hLmEKbD1xLmIuYi56eih0LmZPLmEocS5kKSx0LnopfWNhdGNoKHApe3M9SC5SdShw
-KQpyPUgudHMocCkKaWYobS5jKXtxPXQubi5hKG0uYi5hLmMpLmEKbz1zCm89cT09bnVsbD9vPT1udWxs
-OnE9PT1vCnE9b31lbHNlIHE9ITEKbz1tLmEKaWYocSlvLmM9dC5uLmEobS5iLmEuYykKZWxzZSBvLmM9
-UC5UbChzLHIpCm8uYj0hMApyZXR1cm59aWYobCBpbnN0YW5jZW9mIFAudnMmJmwuYT49NCl7aWYobC5h
-PT09OCl7cT1tLmEKcS5jPXQubi5hKGwuYykKcS5iPSEwfXJldHVybn1pZih0LmUuYihsKSl7bj1tLmIu
-YQpxPW0uYQpxLmM9bC5XNyhuZXcgUC5qWihuKSx0LnopCnEuYj0hMX19LAokUzowfQpQLmpaLnByb3Rv
-dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LAokUzoyOX0KUC5ycS5wcm90b3R5cGU9
-ewokMDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGwKdHJ5e3E9dGhpcy5hCnA9cS5hCm89cC4k
-dGkKbj1vLmMKbT1uLmEodGhpcy5iKQpxLmM9cC5iLmIuYnYoby5DKCIyLygxKSIpLmEocC5kKSxtLG8u
-QygiMi8iKSxuKX1jYXRjaChsKXtzPUguUnUobCkKcj1ILnRzKGwpCnE9dGhpcy5hCnEuYz1QLlRsKHMs
-cikKcS5iPSEwfX0sCiRTOjB9ClAuUlcucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyLHEs
-cCxvLG4sbSxsLGs9dGhpcwp0cnl7cz10Lm4uYShrLmEuYS5jKQpwPWsuYgppZihILm9UKHAuYS5IUihz
-KSkmJnAuYS5lIT1udWxsKXtwLmM9cC5hLkt3KHMpCnAuYj0hMX19Y2F0Y2gobyl7cj1ILlJ1KG8pCnE9
-SC50cyhvKQpwPXQubi5hKGsuYS5hLmMpCm49cC5hCm09cgpsPWsuYgppZihuPT1udWxsP209PW51bGw6
-bj09PW0pbC5jPXAKZWxzZSBsLmM9UC5UbChyLHEpCmwuYj0hMH19LAokUzowfQpQLk9NLnByb3RvdHlw
-ZT17fQpQLnFoLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9e30sbz1u
-ZXcgUC52cygkLlgzLHQuZkopCnAuYT0wCnM9SC5MaChxKQpyPXMuQygifigxKT8iKS5hKG5ldyBQLkI1
-KHAscSkpCnQuWi5hKG5ldyBQLnVPKHAsbykpClcuSkUocS5hLHEuYixyLCExLHMuYykKcmV0dXJuIG99
-fQpQLkI1LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe0guTGgodGhpcy5iKS5jLmEoYSk7Kyt0aGlz
-LmEuYX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIEguTGgodGhpcy5iKS5DKCJ+KDEpIil9fQpQLnVPLnBy
-b3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5iLHI9cy4kdGkscT1yLkMoIjEvIikuYSh0
-aGlzLmEuYSkscD1zLmFoKCkKci5jLmEocSkKcy5hPTQKcy5jPXEKUC5IWihzLHApfSwKJFM6MH0KUC5N
-Ty5wcm90b3R5cGU9e30KUC5rVC5wcm90b3R5cGU9e30KUC54SS5wcm90b3R5cGU9e30KUC5tMC5wcm90
-b3R5cGU9eyRpUW06MX0KUC5wSy5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzPUguYih0aGlz
-LmEpCnMuc3RhY2s9Si5qKHRoaXMuYikKdGhyb3cgc30sCiRTOjB9ClAuSmkucHJvdG90eXBlPXsKYkg6
-ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9bnVsbAp0Lk0uYShhKQp0cnl7aWYoQy5OVT09PSQuWDMpe2Eu
-JDAoKQpyZXR1cm59UC5UOChwLHAsdGhpcyxhLHQuSCl9Y2F0Y2gocSl7cz1ILlJ1KHEpCnI9SC50cyhx
-KQpQLkwyKHAscCx0aGlzLHMsdC5sLmEocikpfX0sCkRsOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEs
-cD1udWxsCmMuQygifigwKSIpLmEoYSkKYy5hKGIpCnRyeXtpZihDLk5VPT09JC5YMyl7YS4kMShiKQpy
-ZXR1cm59UC55dihwLHAsdGhpcyxhLGIsdC5ILGMpfWNhdGNoKHEpe3M9SC5SdShxKQpyPUgudHMocSkK
-UC5MMihwLHAsdGhpcyxzLHQubC5hKHIpKX19LApHWTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuVnAo
-dGhpcyx0Lk0uYShhKSl9LApQeTpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC5PUih0aGlzLGIuQygi
-figwKSIpLmEoYSksYil9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51bGx9LAp6ejpmdW5jdGlvbihh
-LGIpe2IuQygiMCgpIikuYShhKQppZigkLlgzPT09Qy5OVSlyZXR1cm4gYS4kMCgpCnJldHVybiBQLlQ4
-KG51bGwsbnVsbCx0aGlzLGEsYil9LApidjpmdW5jdGlvbihhLGIsYyxkKXtjLkMoIkA8MD4iKS5LcShk
-KS5DKCIxKDIpIikuYShhKQpkLmEoYikKaWYoJC5YMz09PUMuTlUpcmV0dXJuIGEuJDEoYikKcmV0dXJu
-IFAueXYobnVsbCxudWxsLHRoaXMsYSxiLGMsZCl9LApycDpmdW5jdGlvbihhLGIsYyxkLGUsZil7ZC5D
-KCJAPDA+IikuS3EoZSkuS3EoZikuQygiMSgyLDMpIikuYShhKQplLmEoYikKZi5hKGMpCmlmKCQuWDM9
-PT1DLk5VKXJldHVybiBhLiQyKGIsYykKcmV0dXJuIFAuUXgobnVsbCxudWxsLHRoaXMsYSxiLGMsZCxl
-LGYpfSwKTGo6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGIuQygiQDwwPiIpLktxKGMpLktxKGQpLkMo
-IjEoMiwzKSIpLmEoYSl9fQpQLlZwLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMu
-YS5iSCh0aGlzLmIpfSwKJFM6MH0KUC5PUi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcz10
-aGlzLmMKcmV0dXJuIHRoaXMuYS5EbCh0aGlzLmIscy5hKGEpLHMpfSwKJFM6ZnVuY3Rpb24oKXtyZXR1
-cm4gdGhpcy5jLkMoIn4oMCkiKX19ClAuYjYucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9
-dGhpcyxyPW5ldyBQLmxtKHMscy5yLEguTGgocykuQygibG08MT4iKSkKci5jPXMuZQpyZXR1cm4gcn0s
-CmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
-YT09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYSE9PTB9LAp0ZzpmdW5jdGlvbihhLGIp
-e3ZhciBzLHIKaWYodHlwZW9mIGI9PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpe3M9dGhpcy5iCmlm
-KHM9PW51bGwpcmV0dXJuITEKcmV0dXJuIHQubS5hKHNbYl0pIT1udWxsfWVsc2V7cj10aGlzLlBSKGIp
-CnJldHVybiByfX0sClBSOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZAppZihzPT1udWxsKXJldHVybiEx
-CnJldHVybiB0aGlzLkRGKHNbdGhpcy5OKGEpXSxhKT49MH0sCmk6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
-LHE9dGhpcwpILkxoKHEpLmMuYShiKQppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19f
-Iil7cz1xLmIKcmV0dXJuIHEuYlEocz09bnVsbD9xLmI9UC5UMigpOnMsYil9ZWxzZSBpZih0eXBlb2Yg
-Yj09Im51bWJlciImJihiJjEwNzM3NDE4MjMpPT09Yil7cj1xLmMKcmV0dXJuIHEuYlEocj09bnVsbD9x
-LmM9UC5UMigpOnIsYil9ZWxzZSByZXR1cm4gcS5CNyhiKX0sCkI3OmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cSxwPXRoaXMKSC5MaChwKS5jLmEoYSkKcz1wLmQKaWYocz09bnVsbClzPXAuZD1QLlQyKCkKcj1wLk4o
-YSkKcT1zW3JdCmlmKHE9PW51bGwpc1tyXT1bcC55byhhKV0KZWxzZXtpZihwLkRGKHEsYSk+PTApcmV0
-dXJuITEKcS5wdXNoKHAueW8oYSkpfXJldHVybiEwfSwKUjpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMK
-aWYodHlwZW9mIGI9PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpcmV0dXJuIHMuSChzLmIsYikKZWxz
-ZSBpZih0eXBlb2YgYj09Im51bWJlciImJihiJjEwNzM3NDE4MjMpPT09YilyZXR1cm4gcy5IKHMuYyxi
-KQplbHNlIHJldHVybiBzLnFnKGIpfSwKcWc6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbz10aGlzLG49
-by5kCmlmKG49PW51bGwpcmV0dXJuITEKcz1vLk4oYSkKcj1uW3NdCnE9by5ERihyLGEpCmlmKHE8MCly
-ZXR1cm4hMQpwPXIuc3BsaWNlKHEsMSlbMF0KaWYoMD09PXIubGVuZ3RoKWRlbGV0ZSBuW3NdCm8uRyhw
-KQpyZXR1cm4hMH0sCmJROmZ1bmN0aW9uKGEsYil7SC5MaCh0aGlzKS5jLmEoYikKaWYodC5tLmEoYVti
-XSkhPW51bGwpcmV0dXJuITEKYVtiXT10aGlzLnlvKGIpCnJldHVybiEwfSwKSDpmdW5jdGlvbihhLGIp
-e3ZhciBzCmlmKGE9PW51bGwpcmV0dXJuITEKcz10Lm0uYShhW2JdKQppZihzPT1udWxsKXJldHVybiEx
-CnRoaXMuRyhzKQpkZWxldGUgYVtiXQpyZXR1cm4hMH0sClM6ZnVuY3Rpb24oKXt0aGlzLnI9dGhpcy5y
-KzEmMTA3Mzc0MTgyM30sCnlvOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcyxxPW5ldyBQLmJuKEguTGgo
-cikuYy5hKGEpKQppZihyLmU9PW51bGwpci5lPXIuZj1xCmVsc2V7cz1yLmYKcy50b1N0cmluZwpxLmM9
-cwpyLmY9cy5iPXF9KytyLmEKci5TKCkKcmV0dXJuIHF9LApHOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMs
-cj1hLmMscT1hLmIKaWYocj09bnVsbClzLmU9cQplbHNlIHIuYj1xCmlmKHE9PW51bGwpcy5mPXIKZWxz
-ZSBxLmM9cjstLXMuYQpzLlMoKX0sCk46ZnVuY3Rpb24oYSl7cmV0dXJuIEouaGYoYSkmMTA3Mzc0MTgy
-M30sCkRGOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZihhPT1udWxsKXJldHVybi0xCnM9YS5sZW5ndGgK
-Zm9yKHI9MDtyPHM7KytyKWlmKEouUk0oYVtyXS5hLGIpKXJldHVybiByCnJldHVybi0xfX0KUC5ibi5w
-cm90b3R5cGU9e30KUC5sbS5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9LApG
-OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYyxxPXMuYQppZihzLmIhPT1xLnIpdGhyb3cgSC5iKFAu
-YTQocSkpCmVsc2UgaWYocj09bnVsbCl7cy5zaihudWxsKQpyZXR1cm4hMX1lbHNle3Muc2oocy4kdGku
-QygiMT8iKS5hKHIuYSkpCnMuYz1yLmIKcmV0dXJuITB9fSwKc2o6ZnVuY3Rpb24oYSl7dGhpcy5kPXRo
-aXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KUC5tVy5wcm90b3R5cGU9e30KUC51eS5wcm90b3R5
-cGU9eyRpYlE6MSwkaWNYOjEsJGl6TToxfQpQLmxELnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3Jl
-dHVybiBuZXcgSC5hNyhhLHRoaXMuZ0EoYSksSC56KGEpLkMoImE3PGxELkU+IikpfSwKRTpmdW5jdGlv
-bihhLGIpe3JldHVybiB0aGlzLnEoYSxiKX0sCks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCkgueihhKS5D
-KCJ+KGxELkUpIikuYShiKQpzPXRoaXMuZ0EoYSkKZm9yKHI9MDtyPHM7KytyKXtiLiQxKHRoaXMucShh
-LHIpKQppZihzIT09dGhpcy5nQShhKSl0aHJvdyBILmIoUC5hNChhKSl9fSwKZ2wwOmZ1bmN0aW9uKGEp
-e3JldHVybiB0aGlzLmdBKGEpPT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4hdGhpcy5nbDAoYSl9
-LApFMjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC56KGEpCnJldHVybiBuZXcgSC5sSihhLHMuS3EoYyku
-QygiMShsRC5FKSIpLmEoYikscy5DKCJAPGxELkU+IikuS3EoYykuQygibEo8MSwyPiIpKX0sCmVSOmZ1
-bmN0aW9uKGEsYil7cmV0dXJuIEgucUMoYSxiLG51bGwsSC56KGEpLkMoImxELkUiKSl9LApkcjpmdW5j
-dGlvbihhLGIpe3JldHVybiBuZXcgSC5qVihhLEgueihhKS5DKCJAPGxELkU+IikuS3EoYikuQygialY8
-MSwyPiIpKX0sCmR1OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzCkgueihhKS5DKCJsRC5FPyIpLmEoZCkK
-UC5qQihiLGMsdGhpcy5nQShhKSkKZm9yKHM9YjtzPGM7KytzKXRoaXMuWTUoYSxzLGQpfSwKdzpmdW5j
-dGlvbihhKXtyZXR1cm4gUC5XRShhLCJbIiwiXSIpfX0KUC5pbC5wcm90b3R5cGU9e30KUC5yYS5wcm90
-b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5hCmlmKCFyLmEpdGhpcy5iLmErPSIs
-ICIKci5hPSExCnI9dGhpcy5iCnM9ci5hKz1ILkVqKGEpCnIuYT1zKyI6ICIKci5hKz1ILkVqKGIpfSwK
-JFM6MTF9ClAuWWsucHJvdG90eXBlPXsKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC5MaCh0aGlzKS5D
-KCJ+KFlrLkssWWsuVikiKS5hKGIpCmZvcihzPUouSVQodGhpcy5ndmMoKSk7cy5GKCk7KXtyPXMuZ2wo
-KQpiLiQyKHIsdGhpcy5xKDAscikpfX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gSi5NMSh0aGlzLmd2
-YygpLG5ldyBQLnlRKHRoaXMpLEguTGgodGhpcykuQygiTjM8WWsuSyxZay5WPiIpKX0sCng0OmZ1bmN0
-aW9uKGEpe3JldHVybiBKLnpsKHRoaXMuZ3ZjKCksYSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gSi5I
-bSh0aGlzLmd2YygpKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmd2YygpKX0sCnc6
-ZnVuY3Rpb24oYSl7cmV0dXJuIFAubk8odGhpcyl9LAokaVowOjF9ClAueVEucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hLHI9SC5MaChzKQpyLkMoIllrLksiKS5hKGEpCnJldHVybiBu
-ZXcgUC5OMyhhLHMucSgwLGEpLHIuQygiQDxZay5LPiIpLktxKHIuQygiWWsuViIpKS5DKCJOMzwxLDI+
-IikpfSwKJFM6ZnVuY3Rpb24oKXtyZXR1cm4gSC5MaCh0aGlzLmEpLkMoIk4zPFlrLkssWWsuVj4oWWsu
-SykiKX19ClAuS1AucHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykK
-cy5jLmEoYikKcy5RWzFdLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgdW5tb2RpZmlh
-YmxlIG1hcCIpKX19ClAuUG4ucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEu
-cSgwLGIpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKdGhpcy5hLlk1KDAscy5j
-LmEoYikscy5RWzFdLmEoYykpfSwKeDQ6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS54NChhKX0sCks6
-ZnVuY3Rpb24oYSxiKXt0aGlzLmEuSygwLEguTGgodGhpcykuQygifigxLDIpIikuYShiKSl9LApnbDA6
-ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmdsMChzKX0sCmdBOmZ1bmN0aW9uKGEpe3Zh
-ciBzPXRoaXMuYQpyZXR1cm4gcy5nQShzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIEouaih0aGlzLmEp
-fSwKZ1B1OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nUHUocyl9LAokaVowOjF9ClAu
-R2oucHJvdG90eXBlPXt9ClAubGYucHJvdG90eXBlPXsKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlz
-LmdBKHRoaXMpPT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKSE9PTB9LApG
-VjpmdW5jdGlvbihhLGIpe3ZhciBzCmZvcihzPUouSVQoSC5MaCh0aGlzKS5DKCJjWDxsZi5FPiIpLmEo
-YikpO3MuRigpOyl0aGlzLmkoMCxzLmdsKCkpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gUC5XRSh0aGlz
-LCJ7IiwifSIpfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5nbSh0aGlzKQppZighci5GKCkp
-cmV0dXJuIiIKaWYoYj09PSIiKXtzPSIiCmRvIHMrPUguRWooci5kKQp3aGlsZShyLkYoKSl9ZWxzZXtz
-PUguRWooci5kKQpmb3IoO3IuRigpOylzPXMrYitILkVqKHIuZCl9cmV0dXJuIHMuY2hhckNvZGVBdCgw
-KT09MD9zOnN9LAplUjpmdW5jdGlvbihhLGIpe3JldHVybiBILmJLKHRoaXMsYixILkxoKHRoaXMpLkMo
-ImxmLkUiKSl9LApFOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHA9ImluZGV4IgpILmNiKGIscCx0LlMp
-ClAuazEoYixwKQpmb3Iocz10aGlzLmdtKHRoaXMpLHI9MDtzLkYoKTspe3E9cy5kCmlmKGI9PT1yKXJl
-dHVybiBxOysrcn10aHJvdyBILmIoUC5DZihiLHRoaXMscCxudWxsLHIpKX19ClAuVmoucHJvdG90eXBl
-PXskaWJROjEsJGljWDoxLCRpeHU6MX0KUC5Ydi5wcm90b3R5cGU9eyRpYlE6MSwkaWNYOjEsJGl4dTox
-fQpQLm5ZLnByb3RvdHlwZT17fQpQLldZLnByb3RvdHlwZT17fQpQLlJVLnByb3RvdHlwZT17fQpQLnBS
-LnByb3RvdHlwZT17fQpQLnV3LnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMu
-YgppZihyPT1udWxsKXJldHVybiB0aGlzLmMucSgwLGIpCmVsc2UgaWYodHlwZW9mIGIhPSJzdHJpbmci
-KXJldHVybiBudWxsCmVsc2V7cz1yW2JdCnJldHVybiB0eXBlb2Ygcz09InVuZGVmaW5lZCI/dGhpcy5m
-YihiKTpzfX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmI9PW51bGw/dGhpcy5jLmE6dGhpcy5D
-ZigpLmxlbmd0aH0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKT09PTB9LApndmM6
-ZnVuY3Rpb24oKXtpZih0aGlzLmI9PW51bGwpe3ZhciBzPXRoaXMuYwpyZXR1cm4gbmV3IEguaTUocyxI
-LkxoKHMpLkMoImk1PDE+IikpfXJldHVybiBuZXcgUC5pOCh0aGlzKX0sClk1OmZ1bmN0aW9uKGEsYixj
-KXt2YXIgcyxyLHE9dGhpcwppZihxLmI9PW51bGwpcS5jLlk1KDAsYixjKQplbHNlIGlmKHEueDQoYikp
-e3M9cS5iCnNbYl09YwpyPXEuYQppZihyPT1udWxsP3MhPW51bGw6ciE9PXMpcltiXT1udWxsfWVsc2Ug
-cS5YSygpLlk1KDAsYixjKX0sCng0OmZ1bmN0aW9uKGEpe2lmKHRoaXMuYj09bnVsbClyZXR1cm4gdGhp
-cy5jLng0KGEpCnJldHVybiBPYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LmNhbGwodGhpcy5h
-LGEpfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG89dGhpcwp0LmNBLmEoYikKaWYoby5iPT1u
-dWxsKXJldHVybiBvLmMuSygwLGIpCnM9by5DZigpCmZvcihyPTA7cjxzLmxlbmd0aDsrK3Ipe3E9c1ty
-XQpwPW8uYltxXQppZih0eXBlb2YgcD09InVuZGVmaW5lZCIpe3A9UC5RZShvLmFbcV0pCm8uYltxXT1w
-fWIuJDIocSxwKQppZihzIT09by5jKXRocm93IEguYihQLmE0KG8pKX19LApDZjpmdW5jdGlvbigpe3Zh
-ciBzPXQuYk0uYSh0aGlzLmMpCmlmKHM9PW51bGwpcz10aGlzLmM9SC5WTShPYmplY3Qua2V5cyh0aGlz
-LmEpLHQucykKcmV0dXJuIHN9LApYSzpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbj10aGlzCmlmKG4u
-Yj09bnVsbClyZXR1cm4gbi5jCnM9UC5GbCh0Lk4sdC56KQpyPW4uQ2YoKQpmb3IocT0wO3A9ci5sZW5n
-dGgscTxwOysrcSl7bz1yW3FdCnMuWTUoMCxvLG4ucSgwLG8pKX1pZihwPT09MClDLk5tLmkociwiIikK
-ZWxzZSBDLk5tLnNBKHIsMCkKbi5hPW4uYj1udWxsCnJldHVybiBuLmM9c30sCmZiOmZ1bmN0aW9uKGEp
-e3ZhciBzCmlmKCFPYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LmNhbGwodGhpcy5hLGEpKXJl
-dHVybiBudWxsCnM9UC5RZSh0aGlzLmFbYV0pCnJldHVybiB0aGlzLmJbYV09c319ClAuaTgucHJvdG90
-eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmdBKHMpfSwKRTpmdW5jdGlv
-bihhLGIpe3ZhciBzPXRoaXMuYQppZihzLmI9PW51bGwpcz1zLmd2YygpLkUoMCxiKQplbHNle3M9cy5D
-ZigpCmlmKGI8MHx8Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpzPXNbYl19cmV0dXJuIHN9LApn
-bTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKaWYocy5iPT1udWxsKXtzPXMuZ3ZjKCkKcz1zLmdtKHMp
-fWVsc2V7cz1zLkNmKCkKcz1uZXcgSi5tMShzLHMubGVuZ3RoLEgudDYocykuQygibTE8MT4iKSl9cmV0
-dXJuIHN9LAp0ZzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEueDQoYil9fQpQLnhyLnByb3RvdHlw
+cGUKcmV0dXJuIGF9aWYoYSBpbnN0YW5jZW9mIFAuTWgpcmV0dXJuIGEKcmV0dXJuIEoua3MoYSl9LApp
+YTpmdW5jdGlvbihhKXtpZih0eXBlb2YgYT09Im51bWJlciIpe2lmKE1hdGguZmxvb3IoYSk9PWEpcmV0
+dXJuIEouYlUucHJvdG90eXBlCnJldHVybiBKLmtELnByb3RvdHlwZX1pZih0eXBlb2YgYT09InN0cmlu
+ZyIpcmV0dXJuIEouRHIucHJvdG90eXBlCmlmKGE9PW51bGwpcmV0dXJuIEoud2UucHJvdG90eXBlCmlm
+KHR5cGVvZiBhPT0iYm9vbGVhbiIpcmV0dXJuIEoueUUucHJvdG90eXBlCmlmKGEuY29uc3RydWN0b3I9
+PUFycmF5KXJldHVybiBKLmpkLnByb3RvdHlwZQppZih0eXBlb2YgYSE9Im9iamVjdCIpe2lmKHR5cGVv
+ZiBhPT0iZnVuY3Rpb24iKXJldHVybiBKLmM1LnByb3RvdHlwZQpyZXR1cm4gYX1pZihhIGluc3RhbmNl
+b2YgUC5NaClyZXR1cm4gYQpyZXR1cm4gSi5rcyhhKX0sCnJZOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBh
+PT0ic3RyaW5nIilyZXR1cm4gSi5Eci5wcm90b3R5cGUKaWYoYT09bnVsbClyZXR1cm4gYQppZighKGEg
+aW5zdGFuY2VvZiBQLk1oKSlyZXR1cm4gSi5rZC5wcm90b3R5cGUKcmV0dXJuIGF9LAp2ZDpmdW5jdGlv
+bihhKXtpZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIEoucUkucHJvdG90eXBlCmlmKGE9PW51bGwp
+cmV0dXJuIGEKaWYoIShhIGluc3RhbmNlb2YgUC5NaCkpcmV0dXJuIEoua2QucHJvdG90eXBlCnJldHVy
+biBhfSwKdzE6ZnVuY3Rpb24oYSl7aWYoYT09bnVsbClyZXR1cm4gYQppZihhLmNvbnN0cnVjdG9yPT1B
+cnJheSlyZXR1cm4gSi5qZC5wcm90b3R5cGUKaWYodHlwZW9mIGEhPSJvYmplY3QiKXtpZih0eXBlb2Yg
+YT09ImZ1bmN0aW9uIilyZXR1cm4gSi5jNS5wcm90b3R5cGUKcmV0dXJuIGF9aWYoYSBpbnN0YW5jZW9m
+IFAuTWgpcmV0dXJuIGEKcmV0dXJuIEoua3MoYSl9LApBNTpmdW5jdGlvbihhLGIpe3JldHVybiBKLncx
+KGEpLmVSKGEsYil9LApEMTpmdW5jdGlvbihhLGIpe3JldHVybiBKLnJZKGEpLk9ZKGEsYil9LApFaDpm
+dW5jdGlvbihhLGIsYyl7cmV0dXJuIEouWUUoYSkubUsoYSxiLGMpfSwKRWw6ZnVuY3Rpb24oYSxiKXty
+ZXR1cm4gSi53MShhKS5kcihhLGIpfSwKRjc6ZnVuY3Rpb24oYSl7cmV0dXJuIEouVTYoYSkuZ29yKGEp
+fSwKRkw6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5yWShhKS5kZChhLGIpfSwKR0E6ZnVuY3Rpb24oYSxi
+KXtyZXR1cm4gSi53MShhKS5FKGEsYil9LApIbTpmdW5jdGlvbihhKXtyZXR1cm4gSi5VNihhKS5nQShh
+KX0sCklUOmZ1bmN0aW9uKGEpe3JldHVybiBKLncxKGEpLmdtKGEpfSwKSnk6ZnVuY3Rpb24oYSxiKXty
+ZXR1cm4gSi5pYShhKS5lNyhhLGIpfSwKS1Y6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5yWShhKS55bihh
+LGIpfSwKTHQ6ZnVuY3Rpb24oYSl7cmV0dXJuIEouWUUoYSkud2coYSl9LApNMTpmdW5jdGlvbihhLGIs
+Yyl7cmV0dXJuIEoudzEoYSkuRTIoYSxiLGMpfSwKTXU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5ZRShh
+KS5zUChhLGIpfSwKUXo6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5yWShhKS5XKGEsYil9LApSTTpmdW5j
+dGlvbihhLGIpe2lmKGE9PW51bGwpcmV0dXJuIGI9PW51bGwKaWYodHlwZW9mIGEhPSJvYmplY3QiKXJl
+dHVybiBiIT1udWxsJiZhPT09YgpyZXR1cm4gSi5pYShhKS5ETihhLGIpfSwKUlg6ZnVuY3Rpb24oYSl7
+cmV0dXJuIEoudzEoYSkuYnIoYSl9LApUMDpmdW5jdGlvbihhKXtyZXR1cm4gSi5yWShhKS5iUyhhKX0s
+ClZ1OmZ1bmN0aW9uKGEpe3JldHVybiBKLnZkKGEpLnpRKGEpfSwKYTY6ZnVuY3Rpb24oYSxiKXtyZXR1
+cm4gSi5yWShhKS5PKGEsYil9LAphdTpmdW5jdGlvbihhLGIpe3JldHVybiBKLnJZKGEpLm5DKGEsYil9
+LApiVDpmdW5jdGlvbihhKXtyZXR1cm4gSi5ZRShhKS5ENChhKX0sCmNIOmZ1bmN0aW9uKGEpe3JldHVy
+biBKLnJZKGEpLmhjKGEpfSwKZFI6ZnVuY3Rpb24oYSl7cmV0dXJuIEouWUUoYSkuZ1AoYSl9LApkWjpm
+dW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gSi5ZRShhKS5PbihhLGIsYyxkKX0sCmRnOmZ1bmN0aW9uKGEs
+YixjLGQpe3JldHVybiBKLnJZKGEpLmk3KGEsYixjLGQpfSwKZGg6ZnVuY3Rpb24oYSl7cmV0dXJuIEou
+WUUoYSkuRkYoYSl9LApkcjpmdW5jdGlvbihhLGIpe3JldHVybiBKLllFKGEpLnNhNChhLGIpfSwKaGY6
+ZnVuY3Rpb24oYSl7cmV0dXJuIEouaWEoYSkuZ2lPKGEpfSwKaWc6ZnVuY3Rpb24oYSl7cmV0dXJuIEou
+WUUoYSkuZ1FnKGEpfSwKbDU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5ZRShhKS5zaGYoYSxiKX0sCmxk
+OmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gSi5yWShhKS5OaihhLGIsYyl9LApwNDpmdW5jdGlvbihhLGIp
+e3JldHVybiBKLnJZKGEpLlRjKGEsYil9LApwYjpmdW5jdGlvbihhLGIpe2lmKHR5cGVvZiBhPT0ibnVt
+YmVyIiYmdHlwZW9mIGI9PSJudW1iZXIiKXJldHVybiBhK2IKcmV0dXJuIEouUWMoYSkuaChhLGIpfSwK
+cTA6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBKLnJZKGEpLlFpKGEsYixjKX0sCnFGOmZ1bmN0aW9uKGEp
+e3JldHVybiBKLllFKGEpLmdWbChhKX0sCnRIOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gSi5ZRShhKS5w
+ayhhLGIsYyl9LAp1OTpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIEoudzEoYSkuWTUoYSxiLGMpfSwKdVU6
+ZnVuY3Rpb24oYSl7cmV0dXJuIEouVTYoYSkuZ2wwKGEpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gSi5p
+YShhKS53KGEpfSwKd2Y6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi5ZRShhKS5zUk4oYSxiKX0sCng5OmZ1
+bmN0aW9uKGEsYil7aWYodHlwZW9mIGI9PT0ibnVtYmVyIilpZihhLmNvbnN0cnVjdG9yPT1BcnJheXx8
+dHlwZW9mIGE9PSJzdHJpbmcifHxILndWKGEsYVt2LmRpc3BhdGNoUHJvcGVydHlOYW1lXSkpaWYoYj4+
+PjA9PT1iJiZiPGEubGVuZ3RoKXJldHVybiBhW2JdCnJldHVybiBKLlU2KGEpLnEoYSxiKX0sCnpsOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIEouVTYoYSkudGcoYSxiKX0sCkd2OmZ1bmN0aW9uIEd2KCl7fSwKeUU6
+ZnVuY3Rpb24geUUoKXt9LAp3ZTpmdW5jdGlvbiB3ZSgpe30sCk1GOmZ1bmN0aW9uIE1GKCl7fSwKaUM6
+ZnVuY3Rpb24gaUMoKXt9LAprZDpmdW5jdGlvbiBrZCgpe30sCmM1OmZ1bmN0aW9uIGM1KCl7fSwKamQ6
+ZnVuY3Rpb24gamQoYSl7dGhpcy4kdGk9YX0sClBvOmZ1bmN0aW9uIFBvKGEpe3RoaXMuJHRpPWF9LApt
+MTpmdW5jdGlvbiBtMShhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9MApfLmQ9bnVsbApf
+LiR0aT1jfSwKcUk6ZnVuY3Rpb24gcUkoKXt9LApiVTpmdW5jdGlvbiBiVSgpe30sCmtEOmZ1bmN0aW9u
+IGtEKCl7fSwKRHI6ZnVuY3Rpb24gRHIoKXt9fSxMPXsKSXE6ZnVuY3Rpb24oKXtDLkJaLkIoZG9jdW1l
+bnQsIkRPTUNvbnRlbnRMb2FkZWQiLG5ldyBMLmUoKSkKQy5vbC5CKHdpbmRvdywicG9wc3RhdGUiLG5l
+dyBMLkwoKSl9LAprejpmdW5jdGlvbihhKXt2YXIgcyxyPXQuZy5hKGEucGFyZW50Tm9kZSkucXVlcnlT
+ZWxlY3RvcigiOnNjb3BlID4gdWwiKSxxPXIuc3R5bGUscD0iIitDLkNELnpRKHIub2Zmc2V0SGVpZ2h0
+KSoyKyJweCIKcS5tYXhIZWlnaHQ9cApxPUoucUYoYSkKcD1xLiR0aQpzPXAuQygifigxKT8iKS5hKG5l
+dyBMLld4KHIsYSkpCnQuWi5hKG51bGwpClcuSkUocS5hLHEuYixzLCExLHAuYyl9LAp5WDpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG8sbixtPSJxdWVyeVNlbGVjdG9yQWxsIixsPWRvY3VtZW50LnF1ZXJ5
+U2VsZWN0b3IoYSksaz10LmcKbC50b1N0cmluZwpzPXQuaApILkRoKGsscywiVCIsbSkKcj10LlIKcT1u
+ZXcgVy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5uYXYtbGluayIpLHIpCnEuSyhxLG5ldyBMLkFPKGIp
+KQpILkRoKGsscywiVCIsbSkKcD1uZXcgVy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5yZWdpb24iKSxy
+KQppZighcC5nbDAocCkpe289bC5xdWVyeVNlbGVjdG9yKCJ0YWJsZVtkYXRhLXBhdGhdIikKby50b1N0
+cmluZwpwLksocCxuZXcgTC5IbyhvLmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3
+KG8pKS5PVSgicGF0aCIpKSkpfUguRGgoayxzLCJUIixtKQpuPW5ldyBXLnd6KGwucXVlcnlTZWxlY3Rv
+ckFsbCgiLmFkZC1oaW50LWxpbmsiKSxyKQpuLksobixuZXcgTC5JQygpKX0sClE2OmZ1bmN0aW9uKGEs
+YixjKXt2YXIgcz1uZXcgWE1MSHR0cFJlcXVlc3QoKQpDLkR0LmVvKHMsIkdFVCIsTC5RNChhLGIpLCEw
+KQpzLnNldFJlcXVlc3RIZWFkZXIoIkNvbnRlbnQtVHlwZSIsImFwcGxpY2F0aW9uL2pzb247IGNoYXJz
+ZXQ9VVRGLTgiKQpyZXR1cm4gTC5MVShzLG51bGwsYy5DKCIwKiIpKX0sCnR5OmZ1bmN0aW9uKGEsYil7
+dmFyIHM9bmV3IFhNTEh0dHBSZXF1ZXN0KCkscj10LlgKQy5EdC5lbyhzLCJQT1NUIixMLlE0KGEsUC5G
+bChyLHIpKSwhMCkKcy5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9q
+c29uOyBjaGFyc2V0PVVURi04IikKcmV0dXJuIEwuTFUocyxiLHQudCl9LApMVTpmdW5jdGlvbihhLGIs
+Yyl7cmV0dXJuIEwuVGcoYSxiLGMsYy5DKCIwKiIpKX0sClRnOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBz
+PTAscj1QLkZYKGQpLHEscD0yLG8sbj1bXSxtLGwsayxqLGksaCxnLGYsZQp2YXIgJGFzeW5jJExVPVAu
+bHooZnVuY3Rpb24oYTAsYTEpe2lmKGEwPT09MSl7bz1hMQpzPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7
+Y2FzZSAwOmg9bmV3IFAuWmYobmV3IFAudnMoJC5YMyx0LmdWKSx0LmJDKQpnPXQuZWIKZj1nLmEobmV3
+IEwuZkMoaCxhKSkKdC5aLmEobnVsbCkKaz10LmVRClcuSkUoYSwibG9hZCIsZiwhMSxrKQpXLkpFKGEs
+ImVycm9yIixnLmEoaC5nWUooKSksITEsaykKYS5zZW5kKGI9PW51bGw/bnVsbDpDLkN0Lk9CKGIsbnVs
+bCkpCnA9NApzPTcKcmV0dXJuIFAualEoaC5hLCRhc3luYyRMVSkKY2FzZSA3OnA9MgpzPTYKYnJlYWsK
+Y2FzZSA0OnA9MwplPW8KSC5SdShlKQptPUgudHMoZSkKZz1hLnJlYWR5U3RhdGUKaWYoZz09PTQmJmEu
+c3RhdHVzPT09MCl0aHJvdyBILmIoTC5URygiRXJyb3IgcmVhY2hpbmcgbWlncmF0aW9uIHByZXZpZXcg
+c2VydmVyIiwiVGhpcyB1c3VhbGx5IGhhcHBlbnMgYmVjYXVzZSB0aGUgbWlncmF0aW9uIHByZXZpZXcg
+c2VydmVyIGhhcyBleGl0ZWQuICBGb3JcbmV4YW1wbGUgaXQgbWF5IGhhdmUgYmVlbiBhYm9ydGVkIHdp
+dGggQ3RybC1DLCBvciB5b3UgbWF5IGhhdmUgY29tcGxldGVkIHRoaXNcbm1pZ3JhdGlvbiwgb3IgYW4g
+ZXhjZXB0aW9uIG1heSBoYXZlIG9jY3VycmVkLiAgUGxlYXNlIGNoZWNrIHRoZSBjb25zb2xlIHdoZXJl
+XG55b3UgaW52b2tlZCBgZGFydCBtaWdyYXRlYCB0byB2ZXJpZnkgdGhhdCB0aGUgcHJldmlldyBzZXJ2
+ZXIgaXMgc3RpbGwgcnVubmluZy5cbiIpKQplbHNle2w9bmV3IEgubEooSC5RSShbInJlYWR5U3RhdGU9
+IitILkVqKGcpLCJyZXNwb25zZVRleHQ9IitDLkN0Lk9CKGEucmVzcG9uc2VUZXh0LG51bGwpLCJyZXNw
+b25zZVR5cGU9IitDLkN0Lk9CKGEucmVzcG9uc2VUeXBlLG51bGwpLCJyZXNwb25zZVVybD0iK0MuQ3Qu
+T0IoYS5yZXNwb25zZVVSTCxudWxsKSwic3RhdHVzPSIrSC5FaihhLnN0YXR1cyksInN0YXR1c1RleHQ9
+IitDLkN0Lk9CKGEuc3RhdHVzVGV4dCxudWxsKV0sdC5pKSx0LmVxLmEobmV3IEwuVG0oKSksdC5mUCku
+aygwLCIsICIpCnRocm93IEguYihQLlRsKCJFcnJvciByZWFjaGluZyBtaWdyYXRpb24gcHJldmlldyBz
+ZXJ2ZXI6ICIrSC5FaihsKSxtKSl9cz02CmJyZWFrCmNhc2UgMzpzPTIKYnJlYWsKY2FzZSA2OmlmKGEu
+c3RhdHVzPT09NDAxKXRocm93IEguYihMLlRHKCJVbmF1dGhvcml6ZWQgcmVzcG9uc2UgZnJvbSBtaWdy
+YXRpb24gcHJldmlldyBzZXJ2ZXIiLCJUaGUgbWlncmF0aW9uIHByZXZpZXcgc2VydmVyIGhhcyBkZXRl
+Y3RlZCBhIG1pc21hdGNoIGJldHdlZW4gdGhlIGF1dGhUb2tlbiBpblxueW91ciBVUkwgYW5kIHRoZSB0
+b2tlbiB0aGF0IHdhcyBnZW5lcmF0ZWQgYXQgdGhlIHRpbWUgdGhhdCBgZGFydCBtaWdyYXRlYCB3YXNc
+bnJ1bi4gIEhhdmUgeW91IHJlc3RhcnRlZCB0aGUgbWlncmF0aW9uIHNlcnZlciByZWNlbnRseT8gIElm
+IHNvLCB5b3UnbGwgbmVlZCB0b1xuY2hlY2sgaXRzIG91dHB1dCBmb3IgYSBmcmVzaCBVUkwsIGFuZCB1
+c2UgdGhhdCBVUkwgdG8gcGVyZm9ybSB5b3VyIG1pZ3JhdGlvbi5cbiIpKQppPUMuQ3QucFcoMCxhLnJl
+c3BvbnNlVGV4dCxudWxsKQppZihhLnN0YXR1cz09PTIwMCl7cT1jLkMoIjAqIikuYShpKQpzPTEKYnJl
+YWt9ZWxzZSB0aHJvdyBILmIoaSkKY2FzZSAxOnJldHVybiBQLnlDKHEscikKY2FzZSAyOnJldHVybiBQ
+LmYzKG8scil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJExVLHIpfSwKYUs6ZnVuY3Rpb24oYSl7dmFyIHM9
+UC5oSyhhKS5naFkoKS5xKDAsImxpbmUiKQpyZXR1cm4gcz09bnVsbD9udWxsOkguSHAocyxudWxsKX0s
+Ckc2OmZ1bmN0aW9uKGEpe3ZhciBzPVAuaEsoYSkuZ2hZKCkucSgwLCJvZmZzZXQiKQpyZXR1cm4gcz09
+bnVsbD9udWxsOkguSHAocyxudWxsKX0sCmk2OmZ1bmN0aW9uKGEpe3JldHVybiBMLm5XKHQuTy5hKGEp
+KX0sCm5XOmZ1bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQueikscT0xLHAsbz1bXSxuLG0sbCxrLGos
+aSxoCnZhciAkYXN5bmMkaTY9UC5seihmdW5jdGlvbihiLGMpe2lmKGI9PT0xKXtwPWMKcz1xfXdoaWxl
+KHRydWUpc3dpdGNoKHMpe2Nhc2UgMDppPXQuZy5hKFcucWMoYS5jdXJyZW50VGFyZ2V0KSkuZ2V0QXR0
+cmlidXRlKCJocmVmIikKYS5wcmV2ZW50RGVmYXVsdCgpCnE9MwprPWRvY3VtZW50Cm49Qy5DRC56UShr
+LnF1ZXJ5U2VsZWN0b3IoIi5jb250ZW50Iikuc2Nyb2xsVG9wKQpzPTYKcmV0dXJuIFAualEoTC50eShp
+LG51bGwpLCRhc3luYyRpNikKY2FzZSA2OnM9NwpyZXR1cm4gUC5qUShMLkc3KHdpbmRvdy5sb2NhdGlv
+bi5wYXRobmFtZSxudWxsLG51bGwsITEsbnVsbCksJGFzeW5jJGk2KQpjYXNlIDc6ay5ib2R5LmNsYXNz
+TGlzdC5hZGQoIm5lZWRzLXJlcnVuIikKaz1rLnF1ZXJ5U2VsZWN0b3IoIi5jb250ZW50IikKay50b1N0
+cmluZwprLnNjcm9sbFRvcD1KLlZ1KG4pCnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpoPXAKbT1ILlJ1
+KGgpCmw9SC50cyhoKQpMLkMyKCJjb3VsZG4ndCBhZGQvcmVtb3ZlIGhpbnQiLG0sbCkKcz01CmJyZWFr
+CmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQ
+LmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJGk2LHIpfSwKQzI6ZnVuY3Rpb24oYSxiLGMpe3Zh
+ciBzLHIscSxwLG8sbj0iZXhjZXB0aW9uIixtPSJzdGFja1RyYWNlIgppZih0LnQuYihiKSYmSi5STShi
+LnEoMCwic3VjY2VzcyIpLCExKSYmYi54NChuKSYmYi54NChtKSl7cz1KLlU2KGIpCnI9SC5oKHMucShi
+LG4pKQpjPXMucShiLG0pCnE9bnVsbH1lbHNlIGlmKGIgaW5zdGFuY2VvZiBMLlFXKXtyPWIuYQpxPWIu
+Yn1lbHNle3I9Si53KGIpCnE9bnVsbH1pZihxPT1udWxsKXE9YwpzPWRvY3VtZW50CnA9cy5xdWVyeVNl
+bGVjdG9yKCIucG9wdXAtcGFuZSIpCnAucXVlcnlTZWxlY3RvcigiaDIiKS5pbm5lclRleHQ9YQpwLnF1
+ZXJ5U2VsZWN0b3IoInAiKS5pbm5lclRleHQ9cgpwLnF1ZXJ5U2VsZWN0b3IoInByZSIpLmlubmVyVGV4
+dD1KLncocSkKbz10LmRkLmEocC5xdWVyeVNlbGVjdG9yKCJhLmJvdHRvbSIpKTsobyYmQy54bikuc0xV
+KG8sUC5YZCgiaHR0cHMiLCJnaXRodWIuY29tIiwiZGFydC1sYW5nL3Nkay9pc3N1ZXMvbmV3IixQLkVG
+KFsidGl0bGUiLCJDdXN0b21lci1yZXBvcnRlZCBpc3N1ZSB3aXRoIE5OQkQgbWlncmF0aW9uIHRvb2w6
+ICIrYSwibGFiZWxzIix1LmQsImJvZHkiLGErIlxuXG5FcnJvcjogIitILkVqKHIpKyJcblxuUGxlYXNl
+IGZpbGwgaW4gdGhlIGZvbGxvd2luZzpcblxuKipOYW1lIG9mIHBhY2thZ2UgYmVpbmcgbWlncmF0ZWQg
+KGlmIHB1YmxpYykqKjpcbioqV2hhdCBJIHdhcyBkb2luZyB3aGVuIHRoaXMgaXNzdWUgb2NjdXJyZWQq
+KjpcbioqSXMgaXQgcG9zc2libGUgdG8gd29yayBhcm91bmQgdGhpcyBpc3N1ZSoqOlxuKipIYXMgdGhp
+cyBpc3N1ZSBoYXBwZW5lZCBiZWZvcmUsIGFuZCBpZiBzbywgaG93IG9mdGVuKio6XG4qKkRhcnQgU0RL
+IHZlcnNpb24qKjogIitILkVqKHMuZ2V0RWxlbWVudEJ5SWQoInNkay12ZXJzaW9uIikudGV4dENvbnRl
+bnQpKyJcbioqQWRkaXRpb25hbCBkZXRhaWxzKio6XG5cblRoYW5rcyBmb3IgZmlsaW5nIVxuXG5TdGFj
+a3RyYWNlOiBfYXV0byBwb3B1bGF0ZWQgYnkgbWlncmF0aW9uIHByZXZpZXcgdG9vbC5fXG5cbmBgYFxu
+IitILkVqKGMpKyJcbmBgYFxuIl0sdC5YLHQueikpLmduRCgpKQpzPW8uc3R5bGUKcy5kaXNwbGF5PSJp
+bml0aWFsIgpzPXAuc3R5bGUKcy5kaXNwbGF5PSJpbml0aWFsIgpzPWErIjogIitILkVqKGIpCndpbmRv
+dwppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3IocykKd2lu
+ZG93CnM9SC5FaihjKQppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUu
+ZXJyb3Iocyl9LAp0MjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG89dC5nLmEoVy5xYyhhLmN1cnJl
+bnRUYXJnZXQpKQphLnByZXZlbnREZWZhdWx0KCkKcz1vLmdldEF0dHJpYnV0ZSgiaHJlZiIpCnI9TC5V
+cyhzKQpxPUwuRzYocykKcD1MLmFLKHMpCmlmKHEhPW51bGwpTC5hZihyLHEscCxiLG5ldyBMLm5UKHIs
+cSxwKSkKZWxzZSBMLmFmKHIsbnVsbCxudWxsLGIsbmV3IEwuTlkocikpfSwKSzA6ZnVuY3Rpb24oYSl7
+dmFyIHMscixxLHA9ZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKQpwLnF1ZXJ5U2Vs
+ZWN0b3IoImgyIikuaW5uZXJUZXh0PSJGYWlsZWQgdG8gcmVydW4gZnJvbSBzb3VyY2VzIgpwLnF1ZXJ5
+U2VsZWN0b3IoInAiKS5pbm5lclRleHQ9IlNvdXJjZXMgY29udGFpbiBzdGF0aWMgYW5hbHlzaXMgZXJy
+b3JzOiIKcz1wLnF1ZXJ5U2VsZWN0b3IoInByZSIpCnI9Si5FbChhLHQuYXcpCnE9SC5MaChyKQpzLmlu
+bmVyVGV4dD1uZXcgSC5sSihyLHEuQygicVUqKGxELkUpIikuYShuZXcgTC51ZSgpKSxxLkMoImxKPGxE
+LkUscVUqPiIpKS5rKDAsIlxuIikKcT1wLnF1ZXJ5U2VsZWN0b3IoImEuYm90dG9tIikuc3R5bGUKcS5k
+aXNwbGF5PSJub25lIgpzPXAuc3R5bGUKcy5kaXNwbGF5PSJpbml0aWFsIn0sCnZVOmZ1bmN0aW9uKCl7
+dmFyIHM9ZG9jdW1lbnQKSC5EaCh0LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFsbCIpCnM9bmV3IFcu
+d3oocy5xdWVyeVNlbGVjdG9yQWxsKCIuY29kZSIpLHQuUikKcy5LKHMsbmV3IEwuZVgoKSl9LApoWDpm
+dW5jdGlvbihhLGIsYyl7cmV0dXJuIEwuWXcoYSxiLGMpfSwKWXc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBz
+PTAscj1QLkZYKHQueikscT0xLHAsbz1bXSxuLG0sbCxrLGosaSxoLGcKdmFyICRhc3luYyRoWD1QLmx6
+KGZ1bmN0aW9uKGQsZSl7aWYoZD09PTEpe3A9ZQpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAw
+OnE9MwpqPXQuWApzPTYKcmV0dXJuIFAualEoTC5RNihhLFAuRUYoWyJyZWdpb24iLCJyZWdpb24iLCJv
+ZmZzZXQiLEguRWooYildLGosaiksdC50KSwkYXN5bmMkaFgpCmNhc2UgNjpuPWUKaj1uCmk9Si5VNihq
+KQptPW5ldyBVLmQyKFUuamYoaS5xKGosImVkaXRzIikpLEguaChpLnEoaiwiZXhwbGFuYXRpb24iKSks
+SC51UChpLnEoaiwibGluZSIpKSxILmgoaS5xKGosImRpc3BsYXlQYXRoIikpLEguaChpLnEoaiwidXJp
+UGF0aCIpKSxVLk5kKGkucShqLCJ0cmFjZXMiKSkpCkwuVDEobSkKTC5GcihhLGIsYykKTC55WCgiLmVk
+aXQtcGFuZWwgLnBhbmVsLWNvbnRlbnQiLCExKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKZz1wCmw9
+SC5SdShnKQprPUgudHMoZykKTC5DMigiY291bGRuJ3QgbG9hZCBlZGl0IGRldGFpbHMiLGwsaykKcz01
+CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJl
+dHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJGhYLHIpfSwKRzc6ZnVuY3Rpb24oYSxi
+LGMsZCxlKXtyZXR1cm4gTC5MNShhLGIsYyxkLGUpfSwKTDU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIg
+cz0wLHI9UC5GWCh0LkgpLHEscD0yLG8sbj1bXSxtLGwsayxqLGksaCxnCnZhciAkYXN5bmMkRzc9UC5s
+eihmdW5jdGlvbihmLGEwKXtpZihmPT09MSl7bz1hMApzPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2Fz
+ZSAwOmlmKCFKLnA0KGEsIi5kYXJ0Iikpe0wuQkUoYSxCLndSKCksZCkKTC5CWChhLG51bGwpCmlmKGUh
+PW51bGwpZS4kMCgpCnM9MQpicmVha31wPTQKaT10LlgKcz03CnJldHVybiBQLmpRKEwuUTYoYSxQLkVG
+KFsiaW5saW5lIiwidHJ1ZSJdLGksaSksdC50KSwkYXN5bmMkRzcpCmNhc2UgNzptPWEwCkwuQkUoYSxC
+LllmKG0pLGQpCkwuZkcoYixjKQpsPUwuVXMoYSkKTC5CWChsLGIpCmlmKGUhPW51bGwpZS4kMCgpCnA9
+MgpzPTYKYnJlYWsKY2FzZSA0OnA9MwpnPW8Kaz1ILlJ1KGcpCmo9SC50cyhnKQpMLkMyKCJjb3VsZG4n
+dCBsb2FkIGRhcnQgZmlsZSAiK2EsayxqKQpzPTYKYnJlYWsKY2FzZSAzOnM9MgpicmVhawpjYXNlIDY6
+Y2FzZSAxOnJldHVybiBQLnlDKHEscikKY2FzZSAyOnJldHVybiBQLmYzKG8scil9fSkKcmV0dXJuIFAu
+REkoJGFzeW5jJEc3LHIpfSwKR2U6ZnVuY3Rpb24oKXt2YXIgcz0wLHI9UC5GWCh0LnopLHE9MSxwLG89
+W10sbixtLGwsayxqLGksaCxnCnZhciAkYXN5bmMkR2U9UC5seihmdW5jdGlvbihhLGIpe2lmKGE9PT0x
+KXtwPWIKcz1xfXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nhc2UgMDpoPSIvX3ByZXZpZXcvbmF2aWdhdGlv
+blRyZWUuanNvbiIKcT0zCnM9NgpyZXR1cm4gUC5qUShMLlE2KGgsQy5DTSx0LmVFKSwkYXN5bmMkR2Up
+CmNhc2UgNjpuPWIKbT1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIubmF2LXRyZWUiKQpKLmw1KG0sIiIp
+Cmo9TC5tSyhuKQokLklSPWoKTC50WChtLGosITApCnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpnPXAK
+bD1ILlJ1KGcpCms9SC50cyhnKQpMLkMyKCJjb3VsZG4ndCBsb2FkIG5hdmlnYXRpb24gdHJlZSIsbCxr
+KQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNl
+IDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkR2Uscil9LApxTzpmdW5jdGlv
+bihhKXt2YXIgcyxyPWEuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkscT1DLkNELnpRKCQuZmkoKS5vZmZz
+ZXRIZWlnaHQpLHA9d2luZG93LmlubmVySGVpZ2h0LG89Qy5DRC56USgkLkRXKCkub2Zmc2V0SGVpZ2h0
+KQppZih0eXBlb2YgcCE9PSJudW1iZXIiKXJldHVybiBwLkhOKCkKcz1yLmJvdHRvbQpzLnRvU3RyaW5n
+CmlmKHM+cC0obysxNCkpSi5kaChhKQplbHNle3A9ci50b3AKcC50b1N0cmluZwppZihwPHErMTQpSi5k
+aChhKX19LApmRzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8KaWYoYSE9bnVsbCl7cz1kb2N1bWVu
+dApyPXMuZ2V0RWxlbWVudEJ5SWQoIm8iK0guRWooYSkpCnE9cy5xdWVyeVNlbGVjdG9yKCIubGluZS0i
+K0guRWooYikpCmlmKHIhPW51bGwpe0wucU8ocikKSi5kUihyKS5pKDAsInRhcmdldCIpfWVsc2UgaWYo
+cSE9bnVsbClMLnFPKHEucGFyZW50RWxlbWVudCkKaWYocSE9bnVsbClKLmRSKHQuZy5hKHEucGFyZW50
+Tm9kZSkpLmkoMCwiaGlnaGxpZ2h0Iil9ZWxzZXtzPWRvY3VtZW50CnA9dC5nCkguRGgocCx0LmgsIlQi
+LCJxdWVyeVNlbGVjdG9yQWxsIikKcz1zLnF1ZXJ5U2VsZWN0b3JBbGwoIi5saW5lLW5vIikKbz1uZXcg
+Vy53eihzLHQuUikKaWYoby5nQShvKT09PTApcmV0dXJuCkwucU8ocC5hKEMudDUuZ3RIKHMpKSl9fSwK
+YWY6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHE9TC5HNih3aW5kb3cubG9jYXRpb24uaHJlZiks
+cD1MLmFLKHdpbmRvdy5sb2NhdGlvbi5ocmVmKQppZihxIT1udWxsKXtzPWRvY3VtZW50LmdldEVsZW1l
+bnRCeUlkKCJvIitILkVqKHEpKQppZihzIT1udWxsKUouZFIocykuUigwLCJ0YXJnZXQiKX1pZihwIT1u
+dWxsKXtyPWRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIi5saW5lLSIrSC5FaihwKSkKaWYociE9bnVsbClK
+LmRSKHIucGFyZW50RWxlbWVudCkuUigwLCJoaWdobGlnaHQiKX1pZihhPT13aW5kb3cubG9jYXRpb24u
+cGF0aG5hbWUpe0wuZkcoYixjKQplLiQwKCl9ZWxzZSBMLkc3KGEsYixjLGQsZSl9LApRNDpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscT1QLmhLKGEpLHA9dC5YCnA9UC5GbChwLHApCmZvcihzPXEuZ2hZKCkscz1z
+LmdQdShzKSxzPXMuZ20ocyk7cy5GKCk7KXtyPXMuZ2woKQpwLlk1KDAsci5hLHIuYil9Zm9yKHM9Yi5n
+UHUoYikscz1zLmdtKHMpO3MuRigpOyl7cj1zLmdsKCkKcC5ZNSgwLHIuYSxyLmIpfXAuWTUoMCwiYXV0
+aFRva2VuIiwkLlVFKCkpCnJldHVybiBxLm5tKDAscCkuZ25EKCl9LApUMTpmdW5jdGlvbihhKXt2YXIg
+cyxyLHEscCxvLG4sbSxsLGssaj0kLmhMKCkKSi5sNShqLCIiKQppZihhPT1udWxsKXtzPWRvY3VtZW50
+LmNyZWF0ZUVsZW1lbnQoInAiKQpDLkx0LnNhNChzLCJTZWUgZGV0YWlscyBhYm91dCBhIHByb3Bvc2Vk
+IGVkaXQuIikKQy5MdC5zUChzLEguUUkoWyJwbGFjZWhvbGRlciJdLHQuaSkpCmouYXBwZW5kQ2hpbGQo
+cykKQy5MdC5GRihzKQpyZXR1cm59cj1hLmQKcT0kLm5VKCkKcD1xLnpmKHIpCm89YS5iCm49ZG9jdW1l
+bnQKbT1xLkhQKHIsSi5UMChuLnF1ZXJ5U2VsZWN0b3IoIi5yb290IikudGV4dENvbnRlbnQpKQpsPWEu
+YwprPW4uY3JlYXRlRWxlbWVudCgicCIpCmouYXBwZW5kQ2hpbGQoaykKay5hcHBlbmRDaGlsZChuLmNy
+ZWF0ZVRleHROb2RlKEguRWoobykrIiBhdCAiKSkKcT10LlgKcT1XLko2KEwuUTQoYS5lLFAuRUYoWyJs
+aW5lIixKLncobCldLHEscSkpKQpxLmFwcGVuZENoaWxkKG4uY3JlYXRlVGV4dE5vZGUoSC5FaihtKSsi
+OiIrSC5FaihsKSsiLiIpKQprLmFwcGVuZENoaWxkKHEpCkouZGgoaykKTC5DQyhhLGoscCkKTC5Geihh
+LGopfSwKTEg6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZT0k
+LnlQKCkKSi5sNShlLCIiKQppZihiLmdBKGIpPT09MCl7cz1kb2N1bWVudApyPXMuY3JlYXRlRWxlbWVu
+dCgicCIpCmUuYXBwZW5kQ2hpbGQocikKci5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKCJObyBw
+cm9wb3NlZCBlZGl0cyIpKX1lbHNlIGZvcihlPWIuZ1B1KGIpLGU9ZS5nbShlKSxzPXQuWCxxPXQuayxw
+PXEuQygifigxKT8iKSxvPXQuWixxPXEuYztlLkYoKTspe249ZS5nbCgpCm09ZG9jdW1lbnQKcj1tLmNy
+ZWF0ZUVsZW1lbnQoInAiKQpsPSQueVAoKQpsLmFwcGVuZENoaWxkKHIpCnIuYXBwZW5kQ2hpbGQobS5j
+cmVhdGVUZXh0Tm9kZShILkVqKG4uYSkrIjoiKSkKaz1tLmNyZWF0ZUVsZW1lbnQoInVsIikKbC5hcHBl
+bmRDaGlsZChrKQpmb3Iobj1KLklUKG4uYik7bi5GKCk7KXtsPW4uZ2woKQpqPW0uY3JlYXRlRWxlbWVu
+dCgibGkiKQprLmFwcGVuZENoaWxkKGopCkouZFIoaikuaSgwLCJlZGl0IikKaT1tLmNyZWF0ZUVsZW1l
+bnQoImEiKQpqLmFwcGVuZENoaWxkKGkpCmkuY2xhc3NMaXN0LmFkZCgiZWRpdC1saW5rIikKaD1sLmMK
+Zz1ILkVqKGgpCmkuc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcoaSkpLk9VKCJv
+ZmZzZXQiKSxnKQpmPWwuYQpnPUguRWooZikKaS5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShu
+ZXcgVy5pNyhpKSkuT1UoImxpbmUiKSxnKQppLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoImxp
+bmUgIitILkVqKGYpKSkKaS5zZXRBdHRyaWJ1dGUoImhyZWYiLEwuUTQod2luZG93LmxvY2F0aW9uLnBh
+dGhuYW1lLFAuRUYoWyJsaW5lIixILkVqKGYpLCJvZmZzZXQiLEguRWooaCldLHMscykpKQpnPXAuYShu
+ZXcgTC5FRShoLGYsYSkpCm8uYShudWxsKQpXLkpFKGksImNsaWNrIixnLCExLHEpCmouYXBwZW5kQ2hp
+bGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiK0guRWoobC5iKSkpfX1pZihjKUwuVDEobnVsbCl9LApGcjpm
+dW5jdGlvbihhLGIsYyl7dmFyIHMscixxPXdpbmRvdy5sb2NhdGlvbixwPVAuaEsoKHEmJkMuRXgpLmdE
+cihxKStILkVqKGEpKQpxPXQuWApxPVAuRmwocSxxKQppZihiIT1udWxsKXEuWTUoMCwib2Zmc2V0IixI
+LkVqKGIpKQppZihjIT1udWxsKXEuWTUoMCwibGluZSIsSC5FaihjKSkKcS5ZNSgwLCJhdXRoVG9rZW4i
+LCQuVUUoKSkKcD1wLm5tKDAscSkKcT13aW5kb3cuaGlzdG9yeQpzPXQuegpyPXAuZ25EKCkKcS50b1N0
+cmluZwpxLnB1c2hTdGF0ZShuZXcgUC5CZihbXSxbXSkuUHYoUC5GbChzLHMpKSwiIixyKX0sCkVuOmZ1
+bmN0aW9uKGEpe3ZhciBzPUoucGIoZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29u
+dGVudCwiLyIpCmlmKEMueEIubkMoYSxzKSlyZXR1cm4gQy54Qi55bihhLHMubGVuZ3RoKQplbHNlIHJl
+dHVybiBhfSwKT3Q6ZnVuY3Rpb24oYSl7c3dpdGNoKGEucil7Y2FzZSBDLmN3OmJyZWFrCmNhc2UgQy5X
+RDphLnI9Qy5YagpicmVhawpjYXNlIEMuWGo6YS5yPUMuV0QKYnJlYWsKY2FzZSBDLmRjOnRocm93IEgu
+YihQLlBWKCJGaWxlICIrSC5FaihhLmMpKyIgc2hvdWxkIG5vdCBoYXZlIGluZGV0ZXJtaW5hdGUgbWln
+cmF0aW9uIHN0YXR1cyIpKX19LAp0YTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9ImNoZWNrX2JveCIscT0i
+dGl0bGUiLHA9Im9wdGVkLW91dCIsbz0ibWlncmF0aW5nIgpzd2l0Y2goYil7Y2FzZSBDLmN3OmEuaW5u
+ZXJUZXh0PXIKcz1KLllFKGEpCnMuZ1AoYSkuaSgwLCJhbHJlYWR5LW1pZ3JhdGVkIikKcy5nUChhKS5p
+KDAsImRpc2FibGVkIikKYS5zZXRBdHRyaWJ1dGUocSwiQWxyZWFkeSBtaWdyYXRlZCIpCmJyZWFrCmNh
+c2UgQy5XRDphLmlubmVyVGV4dD1yCnM9Si5ZRShhKQpzLmdQKGEpLlIoMCxwKQpzLmdQKGEpLmkoMCxv
+KQphLnNldEF0dHJpYnV0ZShxLCJNaWdyYXRpbmcgdG8gbnVsbCBzYWZldHkiKQpicmVhawpjYXNlIEMu
+WGo6YS5pbm5lclRleHQ9ImNoZWNrX2JveF9vdXRsaW5lX2JsYW5rIgpzPUouWUUoYSkKcy5nUChhKS5S
+KDAsbykKcy5nUChhKS5pKDAscCkKYS5zZXRBdHRyaWJ1dGUocSwiT3B0aW5nIG91dCBvZiBudWxsIHNh
+ZmV0eSIpCmJyZWFrCmRlZmF1bHQ6YS5pbm5lclRleHQ9ImluZGV0ZXJtaW5hdGVfY2hlY2tfYm94Igpz
+PUouWUUoYSkKcy5nUChhKS5SKDAsbykKcy5nUChhKS5pKDAscCkKYS5zZXRBdHRyaWJ1dGUocSwiTWl4
+ZWQgc3RhdHVzZXMgb2YgJ21pZ3JhdGluZycgYW5kICdvcHRpbmcgb3V0JyIpCmJyZWFrfX0sCnhuOmZ1
+bmN0aW9uKGEsYil7dmFyIHMscixxPSJkaXNhYmxlZCIscD1iLmdMKCkKTC50YShhLHApCmlmKGIuYz09
+JC5EOSgpLmlubmVyVGV4dCl7cz1iIGluc3RhbmNlb2YgTC5jRCYmIUgub1QoYi54KQpyPUouWUUoYSkK
+aWYocylyLmdQKGEpLmkoMCxxKQplbHNlIHIuZ1AoYSkuUigwLHEpCkwudGEoJC5jMCgpLHApfX0sCkJY
+OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXt9CnEuYT1hCmE9TC5FbihhKQpxLmE9YQpKLmRyKCQuRDko
+KSxhKQpzPWRvY3VtZW50CkguRGgodC5nLHQuaCwiVCIsInF1ZXJ5U2VsZWN0b3JBbGwiKQpzPW5ldyBX
+Lnd6KHMucXVlcnlTZWxlY3RvckFsbCgiLm5hdi1wYW5lbCAubmF2LWxpbmsiKSx0LlIpCnMuSyhzLG5l
+dyBMLlZTKHEpKQpzPSQuSVIKcj1zPT1udWxsP251bGw6TC55dyhzLHEuYSkKaWYocj09bnVsbClKLmRS
+KCQuYk4oKSkuUigwLCJ2aXNpYmxlIikKZWxzZXtKLmRSKCQuYk4oKSkuaSgwLCJ2aXNpYmxlIikKTC50
+YSgkLmMwKCksci5nTCgpKX19LApBUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1iLmIKaWYocSE9bnVs
+bCl7cz10LmcKcj1zLmEocy5hKGEucGFyZW50Tm9kZSkucGFyZW50Tm9kZSkKTC54bihyLnF1ZXJ5U2Vs
+ZWN0b3IoIjpzY29wZSA+IC5zdGF0dXMtaWNvbiIpLHEpCkwuQVIocixxKX19LApiTDpmdW5jdGlvbihh
+LGIpe3ZhciBzLHIscSxwLG8sbixtPSI6c2NvcGUgPiAuc3RhdHVzLWljb24iCmZvcihzPWIuZCxyPXMu
+bGVuZ3RoLHE9dC5nLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytwKXtv
+PXNbcF0Kbj1hLnF1ZXJ5U2VsZWN0b3IoJ1tkYXRhLW5hbWUqPSInK0guRWooVy5MaihvLmMpKSsnIl0n
+KQppZihvIGluc3RhbmNlb2YgTC52dCl7TC5iTChuLG8pCkwueG4obi5xdWVyeVNlbGVjdG9yKG0pLGIp
+fWVsc2UgTC54bihxLmEobi5wYXJlbnROb2RlKS5xdWVyeVNlbGVjdG9yKG0pLG8pfX0sCkJFOmZ1bmN0
+aW9uKGEsYixjKXt2YXIgcz0iLnJlZ2lvbnMiLHI9ZG9jdW1lbnQscT1yLnF1ZXJ5U2VsZWN0b3Iocyks
+cD1yLnF1ZXJ5U2VsZWN0b3IoIi5jb2RlIikKSi50SChxLGIuYSwkLktHKCkpCkoudEgocCxiLmIsJC5L
+RygpKQpMLkxIKGEsYi5kLGMpCmlmKGIuYy5sZW5ndGg8MmU1KUwudlUoKQpMLnlYKCIuY29kZSIsITAp
+CkwueVgocywhMCl9LAp0WDpmdW5jdGlvbihhMSxhMixhMyl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGos
+aSxoLGcsZixlLGQsYz0ibWF0ZXJpYWwtaWNvbnMiLGI9InN0YXR1cy1pY29uIixhPWRvY3VtZW50LGEw
+PWEuY3JlYXRlRWxlbWVudCgidWwiKQphMS5hcHBlbmRDaGlsZChhMCkKZm9yKHM9YTIubGVuZ3RoLHI9
+dC5YLHE9dC5aLHA9MDtwPGEyLmxlbmd0aDthMi5sZW5ndGg9PT1zfHwoMCxILmxrKShhMiksKytwKXtv
+PWEyW3BdCm49YS5jcmVhdGVFbGVtZW50KCJsaSIpCmEwLmFwcGVuZENoaWxkKG4pCmlmKG8gaW5zdGFu
+Y2VvZiBMLnZ0KXttPUouWUUobikKbS5nUChuKS5pKDAsImRpciIpCm4uc2V0QXR0cmlidXRlKCJkYXRh
+LSIrbmV3IFcuU3kobmV3IFcuaTcobikpLk9VKCJuYW1lIiksby5jKQpsPWEuY3JlYXRlRWxlbWVudCgi
+c3BhbiIpCm4uYXBwZW5kQ2hpbGQobCkKaz1KLllFKGwpCmsuZ1AobCkuaSgwLCJhcnJvdyIpCmsuc2hm
+KGwsIiYjeDI1QkM7IikKaj1hLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpKLmRSKGopLmkoMCxjKQpqLmlu
+bmVyVGV4dD0iZm9sZGVyX29wZW4iCm4uYXBwZW5kQ2hpbGQoaikKbi5hcHBlbmRDaGlsZChhLmNyZWF0
+ZVRleHROb2RlKG8uYSkpCkwudFgobixvLmQsITApCmk9YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKaz1K
+LllFKGkpCmsuZ1AoaSkuaSgwLGMpCmkuaW5uZXJUZXh0PSJpbmRldGVybWluYXRlX2NoZWNrX2JveCIK
+ay5nUChpKS5pKDAsYikKTC54bihpLG8pCms9ay5nVmwoaSkKaD1rLiR0aQpnPWguQygifigxKT8iKS5h
+KG5ldyBMLlREKG8sbixpKSkKcS5hKG51bGwpClcuSkUoay5hLGsuYixnLCExLGguYykKbS5tSyhuLGks
+aikKTC5reihsKX1lbHNlIGlmKG8gaW5zdGFuY2VvZiBMLmNEKXtpPWEuY3JlYXRlRWxlbWVudCgic3Bh
+biIpCm09Si5ZRShpKQptLmdQKGkpLmkoMCxjKQppLmlubmVyVGV4dD0iIgptLmdQKGkpLmkoMCxiKQpr
+PUgub1Qoby54KQppZighayltLmdQKGkpLmkoMCwiZGlzYWJsZWQiKQpMLnhuKGksbykKaWYoayl7bT1t
+LmdWbChpKQprPW0uJHRpCmg9ay5DKCJ+KDEpPyIpLmEobmV3IEwuSWYobyxpLG4pKQpxLmEobnVsbCkK
+Vy5KRShtLmEsbS5iLGgsITEsay5jKX1uLmFwcGVuZENoaWxkKGkpCm09YS5jcmVhdGVFbGVtZW50KCJz
+cGFuIikKSi5kUihtKS5pKDAsYykKbS5pbm5lclRleHQ9Imluc2VydF9kcml2ZV9maWxlIgpuLmFwcGVu
+ZENoaWxkKG0pCmY9YS5jcmVhdGVFbGVtZW50KCJhIikKbi5hcHBlbmRDaGlsZChmKQptPUouWUUoZikK
+bS5nUChmKS5pKDAsIm5hdi1saW5rIikKZi5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcg
+Vy5pNyhmKSkuT1UoIm5hbWUiKSxvLmMpCmYuc2V0QXR0cmlidXRlKCJocmVmIixMLlE0KG8uZCxQLkZs
+KHIscikpKQpmLmFwcGVuZENoaWxkKGEuY3JlYXRlVGV4dE5vZGUoby5hKSkKbT1tLmdWbChmKQprPW0u
+JHRpCmg9ay5DKCJ+KDEpPyIpLmEobmV3IEwudEIoKSkKcS5hKG51bGwpClcuSkUobS5hLG0uYixoLCEx
+LGsuYykKZT1vLmUKaWYodHlwZW9mIGUhPT0ibnVtYmVyIilyZXR1cm4gZS5vcygpCmlmKGU+MCl7ZD1h
+LmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpuLmFwcGVuZENoaWxkKGQpCkouZFIoZCkuaSgwLCJlZGl0LWNv
+dW50IikKbT0iIitlKyIgIgppZihlPT09MSlrPSJwcm9wb3NlZCBlZGl0IgplbHNlIGs9InByb3Bvc2Vk
+IGVkaXRzIgpkLnNldEF0dHJpYnV0ZSgidGl0bGUiLG0raykKZC5hcHBlbmRDaGlsZChhLmNyZWF0ZVRl
+eHROb2RlKEMuam4udyhlKSkpfX19fSwKdXo6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPWRvY3VtZW50LHI9
+cy5jcmVhdGVFbGVtZW50KCJidXR0b24iKSxxPXQuayxwPXEuQygifigxKT8iKS5hKG5ldyBMLm0yKGEs
+YykpCnQuWi5hKG51bGwpClcuSkUociwiY2xpY2siLHAsITEscS5jKQpyLmFwcGVuZENoaWxkKHMuY3Jl
+YXRlVGV4dE5vZGUoUi5PWChhLmEpKSkKYi5hcHBlbmRDaGlsZChyKX0sCkZ6OmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoPWEuYQppZihoPT1udWxsKXJldHVybgpzPWRvY3VtZW50
+CnI9cy5jcmVhdGVFbGVtZW50KCJwIikKcT1iLmFwcGVuZENoaWxkKHIpCnI9cy5jcmVhdGVFbGVtZW50
+KCJzcGFuIikKcD10LmkKSi5NdShyLEguUUkoWyJ0eXBlLWRlc2NyaXB0aW9uIl0scCkpCnIuYXBwZW5k
+Q2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgiQWN0aW9ucyIpKQpxLmFwcGVuZENoaWxkKHIpCnEuYXBwZW5k
+Q2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgiOiIpKQpvPXMuY3JlYXRlRWxlbWVudCgicCIpCmIuYXBwZW5k
+Q2hpbGQobykKZm9yKHI9aC5sZW5ndGgsbj10LlEsbT0wO208aC5sZW5ndGg7aC5sZW5ndGg9PT1yfHwo
+MCxILmxrKShoKSwrK20pe2w9aFttXQprPXMuY3JlYXRlRWxlbWVudCgiYSIpCm8uYXBwZW5kQ2hpbGQo
+aykKay5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKGwuYSkpCmsuc2V0QXR0cmlidXRlKCJocmVm
+IixsLmIpCmo9bi5hKEguUUkoWyJhZGQtaGludC1saW5rIiwiYmVmb3JlLWFwcGx5IiwiYnV0dG9uIl0s
+cCkpCmk9Si5kUihrKQppLlYxKDApCmkuRlYoMCxqKX19LApDQzpmdW5jdGlvbihhNCxhNSxhNil7dmFy
+IHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQsYyxiLGEsYTAsYTEsYTIsYTMKZm9yKHM9YTQu
+ZixyPXMubGVuZ3RoLHE9dC5pLHA9dC5RLG89MDtvPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5s
+aykocyksKytvKXtuPXNbb10KbT1kb2N1bWVudApsPW0uY3JlYXRlRWxlbWVudCgicCIpCms9cC5hKEgu
+UUkoWyJ0cmFjZSJdLHEpKQpqPUouZFIobCkKai5WMSgwKQpqLkZWKDAsaykKaT1hNS5hcHBlbmRDaGls
+ZChsKQpsPW0uY3JlYXRlRWxlbWVudCgic3BhbiIpCms9cC5hKEguUUkoWyJ0eXBlLWRlc2NyaXB0aW9u
+Il0scSkpCmo9Si5kUihsKQpqLlYxKDApCmouRlYoMCxrKQpsLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4
+dE5vZGUobi5hKSkKaS5hcHBlbmRDaGlsZChsKQppLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUo
+IjoiKSkKbD1tLmNyZWF0ZUVsZW1lbnQoInVsIikKaz1wLmEoSC5RSShbInRyYWNlIl0scSkpCmo9Si5k
+UihsKQpqLlYxKDApCmouRlYoMCxrKQpoPWkuYXBwZW5kQ2hpbGQobCkKZm9yKGw9bi5iLGs9bC5sZW5n
+dGgsZz0wO2c8bC5sZW5ndGg7bC5sZW5ndGg9PT1rfHwoMCxILmxrKShsKSwrK2cpe2Y9bFtnXQplPW0u
+Y3JlYXRlRWxlbWVudCgibGkiKQpoLmFwcGVuZENoaWxkKGUpCmQ9bS5jcmVhdGVFbGVtZW50KCJzcGFu
+IikKYz1wLmEoSC5RSShbImZ1bmN0aW9uIl0scSkpCmo9Si5kUihkKQpqLlYxKDApCmouRlYoMCxjKQpj
+PWYuYgpMLldqKGQsYz09bnVsbD8idW5rbm93biI6YykKZS5hcHBlbmRDaGlsZChkKQpiPWYuYwppZihi
+IT1udWxsKXtlLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIiAoIikpCmE9Yi5iCmEwPW0uY3Jl
+YXRlRWxlbWVudCgiYSIpCmEwLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoSC5FaihiLmMpKyI6
+IitILkVqKGEpKSkKYTAuc2V0QXR0cmlidXRlKCJocmVmIixiLmEpCmEwLmNsYXNzTGlzdC5hZGQoIm5h
+di1saW5rIikKZS5hcHBlbmRDaGlsZChhMCkKZS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKCIp
+IikpfWUuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiKSkKZD1mLmEKTC5XaihlLGQ9PW51
+bGw/InVua25vd24iOmQpCmQ9Zi5kCmlmKGQubGVuZ3RoIT09MCl7Yz1tLmNyZWF0ZUVsZW1lbnQoInAi
+KQphMT1wLmEoSC5RSShbImRyYXdlciIsImJlZm9yZS1hcHBseSJdLHEpKQpqPUouZFIoYykKai5WMSgw
+KQpqLkZWKDAsYTEpCmEyPWUuYXBwZW5kQ2hpbGQoYykKZm9yKGM9ZC5sZW5ndGgsYTM9MDthMzxkLmxl
+bmd0aDtkLmxlbmd0aD09PWN8fCgwLEgubGspKGQpLCsrYTMpTC51eihkW2EzXSxhMixiKX19fX0sClVz
+OmZ1bmN0aW9uKGEpe3JldHVybiBKLnpsKGEsIj8iKT9DLnhCLk5qKGEsMCxDLnhCLk9ZKGEsIj8iKSk6
+YX0sClRHOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBMLlFXKGEsYil9LAp5dzpmdW5jdGlvbihhLGIp
+e3ZhciBzLHIscSxwCmZvcihzPWEubGVuZ3RoLHI9MDtyPGEubGVuZ3RoO2EubGVuZ3RoPT09c3x8KDAs
+SC5saykoYSksKytyKXtxPWFbcl0KaWYocSBpbnN0YW5jZW9mIEwudnQpe3A9TC55dyhxLmQsYikKaWYo
+cCE9bnVsbClyZXR1cm4gcH1lbHNlIGlmKHEuYz09YilyZXR1cm4gcX1yZXR1cm4gbnVsbH0sCldqOmZ1
+bmN0aW9uKGEsYil7dmFyIHMscixxPUguUUkoYi5zcGxpdCgiLiIpLHQucykscD1DLk5tLmd0SChxKSxv
+PWRvY3VtZW50CmEuYXBwZW5kQ2hpbGQoby5jcmVhdGVUZXh0Tm9kZShwKSkKZm9yKHA9SC5xQyhxLDEs
+bnVsbCx0Lk4pLHA9bmV3IEguYTcocCxwLmdBKHApLHAuJHRpLkMoImE3PGFMLkU+IikpLHM9Si5ZRShh
+KTtwLkYoKTspe3I9cC5kCnMubnooYSwiYmVmb3JlZW5kIiwiJiM4MjAzOy4iLG51bGwsbnVsbCkKYS5h
+cHBlbmRDaGlsZChvLmNyZWF0ZVRleHROb2RlKHIpKX19LAplOmZ1bmN0aW9uIGUoKXt9LApWVzpmdW5j
+dGlvbiBWVyhhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApvWjpmdW5jdGlvbiBvWigp
+e30sCmpyOmZ1bmN0aW9uIGpyKCl7fSwKcWw6ZnVuY3Rpb24gcWwoKXt9LApIaTpmdW5jdGlvbiBIaSgp
+e30sCkJUOmZ1bmN0aW9uIEJUKCl7fSwKUFk6ZnVuY3Rpb24gUFkoKXt9LAp1ODpmdW5jdGlvbiB1OCgp
+e30sCkw6ZnVuY3Rpb24gTCgpe30sCld4OmZ1bmN0aW9uIFd4KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9
+LApBTzpmdW5jdGlvbiBBTyhhKXt0aGlzLmE9YX0sCmROOmZ1bmN0aW9uIGROKGEpe3RoaXMuYT1hfSwK
+SG86ZnVuY3Rpb24gSG8oYSl7dGhpcy5hPWF9LAp4ejpmdW5jdGlvbiB4eihhLGIpe3RoaXMuYT1hCnRo
+aXMuYj1ifSwKSUM6ZnVuY3Rpb24gSUMoKXt9LApmQzpmdW5jdGlvbiBmQyhhLGIpe3RoaXMuYT1hCnRo
+aXMuYj1ifSwKVG06ZnVuY3Rpb24gVG0oKXt9LApuVDpmdW5jdGlvbiBuVChhLGIsYyl7dGhpcy5hPWEK
+dGhpcy5iPWIKdGhpcy5jPWN9LApOWTpmdW5jdGlvbiBOWShhKXt0aGlzLmE9YX0sCnVlOmZ1bmN0aW9u
+IHVlKCl7fSwKZVg6ZnVuY3Rpb24gZVgoKXt9LApFRTpmdW5jdGlvbiBFRShhLGIsYyl7dGhpcy5hPWEK
+dGhpcy5iPWIKdGhpcy5jPWN9LApRTDpmdW5jdGlvbiBRTChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwK
+VlM6ZnVuY3Rpb24gVlMoYSl7dGhpcy5hPWF9LApURDpmdW5jdGlvbiBURChhLGIsYyl7dGhpcy5hPWEK
+dGhpcy5iPWIKdGhpcy5jPWN9LApJZjpmdW5jdGlvbiBJZihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIK
+dGhpcy5jPWN9LAp0QjpmdW5jdGlvbiB0Qigpe30sCm0yOmZ1bmN0aW9uIG0yKGEsYil7dGhpcy5hPWEK
+dGhpcy5iPWJ9LApRVzpmdW5jdGlvbiBRVyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKWEE6ZnVuY3Rp
+b24gWEEoKXt9LApaczpmdW5jdGlvbihhKXt2YXIgcyxyLHE9Si5VNihhKQppZihMLnAyKEguaChxLnEo
+YSwidHlwZSIpKSk9PT1DLlkyKXtzPUguaChxLnEoYSwibmFtZSIpKQpyPUguaChxLnEoYSwicGF0aCIp
+KQpxPXEucShhLCJzdWJ0cmVlIikKcT1uZXcgTC52dChxPT1udWxsP251bGw6TC5tSyhxKSxzLHIpCnEu
+TFYoKQpyZXR1cm4gcX1lbHNle3M9SC5oKHEucShhLCJuYW1lIikpCnI9SC5oKHEucShhLCJwYXRoIikp
+CnJldHVybiBuZXcgTC5jRChILmgocS5xKGEsImhyZWYiKSksSC51UChxLnEoYSwiZWRpdENvdW50Iikp
+LEgueTgocS5xKGEsIndhc0V4cGxpY2l0bHlPcHRlZE91dCIpKSxMLnZCKEgudVAocS5xKGEsIm1pZ3Jh
+dGlvblN0YXR1cyIpKSksSC55OChxLnEoYSwibWlncmF0aW9uU3RhdHVzQ2FuQmVDaGFuZ2VkIikpLHMs
+cil9fSwKbUs6ZnVuY3Rpb24oYSl7dmFyIHMscj1ILlFJKFtdLHQuY1EpCmZvcihzPUouSVQodC5VLmEo
+YSkpO3MuRigpOylyLnB1c2goTC5acyhzLmdsKCkpKQpyZXR1cm4gcn0sClZEOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHIscT1ILlFJKFtdLHQuRykKZm9yKHM9YS5sZW5ndGgscj0wO3I8YS5sZW5ndGg7YS5sZW5ndGg9
+PT1zfHwoMCxILmxrKShhKSwrK3IpcS5wdXNoKGFbcl0uTHQoKSkKcmV0dXJuIHF9LAp2QjpmdW5jdGlv
+bihhKXtpZihhPT1udWxsKXJldHVybiBudWxsCmlmKGE+Pj4wIT09YXx8YT49NClyZXR1cm4gSC5PSChD
+LmwwLGEpCnJldHVybiBDLmwwW2FdfSwKcDI6ZnVuY3Rpb24oYSl7c3dpdGNoKGEpe2Nhc2UiZGlyZWN0
+b3J5IjpyZXR1cm4gQy5ZMgpjYXNlImZpbGUiOnJldHVybiBDLnJmCmRlZmF1bHQ6dGhyb3cgSC5iKFAu
+UFYoIlVucmVjb2duaXplZCBuYXZpZ2F0aW9uIHRyZWUgbm9kZSB0eXBlOiAiK0guRWooYSkpKX19LAp2
+dDpmdW5jdGlvbiB2dChhLGIsYyl7dmFyIF89dGhpcwpfLmQ9YQpfLmE9YgpfLmI9bnVsbApfLmM9Y30s
+CmNEOmZ1bmN0aW9uIGNEKGEsYixjLGQsZSxmLGcpe3ZhciBfPXRoaXMKXy5kPWEKXy5lPWIKXy5mPWMK
+Xy5yPWQKXy54PWUKXy5hPWYKXy5iPW51bGwKXy5jPWd9LApEODpmdW5jdGlvbiBEOCgpe30sCk85OmZ1
+bmN0aW9uIE85KGEpe3RoaXMuYj1hfSwKR2I6ZnVuY3Rpb24gR2IoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
+Yn0sCklWOmZ1bmN0aW9uIElWKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5kPWEKXy5lPWIKXy5mPWMKXy5y
+PWR9fSxNPXsKWUY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsCmZvcihzPWIubGVuZ3Ro
+LHI9MTtyPHM7KytyKXtpZihiW3JdPT1udWxsfHxiW3ItMV0hPW51bGwpY29udGludWUKZm9yKDtzPj0x
+O3M9cSl7cT1zLTEKaWYoYltxXSE9bnVsbClicmVha31wPW5ldyBQLk0oIiIpCm89YSsiKCIKcC5hPW8K
+bj1ILnQ2KGIpCm09bi5DKCJuSDwxPiIpCmw9bmV3IEgubkgoYiwwLHMsbSkKbC5IZChiLDAscyxuLmMp
+Cm09bytuZXcgSC5sSihsLG0uQygicVUoYUwuRSkiKS5hKG5ldyBNLk5vKCkpLG0uQygibEo8YUwuRSxx
+VT4iKSkuaygwLCIsICIpCnAuYT1tCnAuYT1tKygiKTogcGFydCAiKyhyLTEpKyIgd2FzIG51bGwsIGJ1
+dCBwYXJ0ICIrcisiIHdhcyBub3QuIikKdGhyb3cgSC5iKFAueFkocC53KDApKSl9fSwKbEk6ZnVuY3Rp
+b24gbEkoYSl7dGhpcy5hPWF9LApxNzpmdW5jdGlvbiBxNygpe30sCk5vOmZ1bmN0aW9uIE5vKCl7fX0s
+Tz17ClJoOmZ1bmN0aW9uKCl7dmFyIHMscj1udWxsCmlmKFAudW8oKS5nRmkoKSE9PSJmaWxlIilyZXR1
+cm4gJC5FYigpCnM9UC51bygpCmlmKCFDLnhCLlRjKHMuZ0lpKHMpLCIvIikpcmV0dXJuICQuRWIoKQpp
+ZihQLktMKHIsImEvYiIscixyLHIscixyKS50NCgpPT09ImFcXGIiKXJldHVybiAkLktrKCkKcmV0dXJu
+ICQuYkQoKX0sCnpMOmZ1bmN0aW9uIHpMKCl7fX0sUD17CnhnOmZ1bmN0aW9uKCl7dmFyIHMscixxPXt9
+CmlmKHNlbGYuc2NoZWR1bGVJbW1lZGlhdGUhPW51bGwpcmV0dXJuIFAuRVgoKQppZihzZWxmLk11dGF0
+aW9uT2JzZXJ2ZXIhPW51bGwmJnNlbGYuZG9jdW1lbnQhPW51bGwpe3M9c2VsZi5kb2N1bWVudC5jcmVh
+dGVFbGVtZW50KCJkaXYiKQpyPXNlbGYuZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpCnEuYT1u
+dWxsCm5ldyBzZWxmLk11dGF0aW9uT2JzZXJ2ZXIoSC50UihuZXcgUC50aChxKSwxKSkub2JzZXJ2ZShz
+LHtjaGlsZExpc3Q6dHJ1ZX0pCnJldHVybiBuZXcgUC5oYShxLHMscil9ZWxzZSBpZihzZWxmLnNldElt
+bWVkaWF0ZSE9bnVsbClyZXR1cm4gUC55dCgpCnJldHVybiBQLnFXKCl9LApaVjpmdW5jdGlvbihhKXtz
+ZWxmLnNjaGVkdWxlSW1tZWRpYXRlKEgudFIobmV3IFAuVnModC5NLmEoYSkpLDApKX0sCm9BOmZ1bmN0
+aW9uKGEpe3NlbGYuc2V0SW1tZWRpYXRlKEgudFIobmV3IFAuRnQodC5NLmEoYSkpLDApKX0sCkJ6OmZ1
+bmN0aW9uKGEpe3QuTS5hKGEpClAuUU4oMCxhKX0sClFOOmZ1bmN0aW9uKGEsYil7dmFyIHM9bmV3IFAu
+VzMoKQpzLkNZKGEsYikKcmV0dXJuIHN9LApGWDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuaWgobmV3
+IFAudnMoJC5YMyxhLkMoInZzPDA+IikpLGEuQygiaWg8MD4iKSl9LApESTpmdW5jdGlvbihhLGIpe2Eu
+JDIoMCxudWxsKQpiLmI9ITAKcmV0dXJuIGIuYX0sCmpROmZ1bmN0aW9uKGEsYil7UC5KZShhLGIpfSwK
+eUM6ZnVuY3Rpb24oYSxiKXtiLmFNKDAsYSl9LApmMzpmdW5jdGlvbihhLGIpe2IudzAoSC5SdShhKSxI
+LnRzKGEpKX0sCkplOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPW5ldyBQLldNKGIpLHA9bmV3IFAuU1go
+YikKaWYoYSBpbnN0YW5jZW9mIFAudnMpYS5RZChxLHAsdC56KQplbHNle3M9dC56CmlmKHQuZS5iKGEp
+KWEuU3EocSxwLHMpCmVsc2V7cj1uZXcgUC52cygkLlgzLHQuYykKci5hPTQKci5jPWEKci5RZChxLHAs
+cyl9fX0sCmx6OmZ1bmN0aW9uKGEpe3ZhciBzPWZ1bmN0aW9uKGIsYyl7cmV0dXJuIGZ1bmN0aW9uKGQs
+ZSl7d2hpbGUodHJ1ZSl0cnl7YihkLGUpCmJyZWFrfWNhdGNoKHIpe2U9cgpkPWN9fX0oYSwxKQpyZXR1
+cm4gJC5YMy5MaihuZXcgUC5HcyhzKSx0LkgsdC5TLHQueil9LApHUTpmdW5jdGlvbihhKXtyZXR1cm4g
+bmV3IFAuRnkoYSwxKX0sClRoOmZ1bmN0aW9uKCl7cmV0dXJuIEMud1F9LApZbTpmdW5jdGlvbihhKXty
+ZXR1cm4gbmV3IFAuRnkoYSwzKX0sCmwwOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBQLnE0KGEsYi5D
+KCJxNDwwPiIpKX0sClRsOmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5jYihhLCJlcnJvciIsdC5LKQpyZXR1
+cm4gbmV3IFAuQ3cocyxiPT1udWxsP1AudjAoYSk6Yil9LAp2MDpmdW5jdGlvbihhKXt2YXIgcwppZih0
+LnIuYihhKSl7cz1hLmdJSSgpCmlmKHMhPW51bGwpcmV0dXJuIHN9cmV0dXJuIEMucGR9LApBOTpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIscQpmb3Iocz10LmM7cj1hLmEscj09PTI7KWE9cy5hKGEuYykKaWYocj49
+NCl7cT1iLmFoKCkKYi5hPWEuYQpiLmM9YS5jClAuSFooYixxKX1lbHNle3E9dC5GLmEoYi5jKQpiLmE9
+MgpiLmM9YQphLmpRKHEpfX0sCkhaOmZ1bmN0aW9uKGEsYTApe3ZhciBzLHIscSxwLG8sbixtLGwsayxq
+LGksaCxnLGYsZSxkLGM9e30sYj1jLmE9YQpmb3Iocz10Lm4scj10LkYscT10LmU7ITA7KXtwPXt9Cm89
+Yi5hPT09OAppZihhMD09bnVsbCl7aWYobyl7bj1zLmEoYi5jKQpQLlNpKG4uYSxuLmIpfXJldHVybn1w
+LmE9YTAKbT1hMC5hCmZvcihiPWEwO20hPW51bGw7Yj1tLG09bCl7Yi5hPW51bGwKUC5IWihjLmEsYikK
+cC5hPW0KbD1tLmF9az1jLmEKaj1rLmMKcC5iPW8KcC5jPWoKaT0hbwppZihpKXtoPWIuYwpoPShoJjEp
+IT09MHx8KGgmMTUpPT09OH1lbHNlIGg9ITAKaWYoaCl7Zz1iLmIuYgppZihvKXtrPWsuYj09PWcKaz0h
+KGt8fGspfWVsc2Ugaz0hMQppZihrKXtzLmEoaikKUC5TaShqLmEsai5iKQpyZXR1cm59Zj0kLlgzCmlm
+KGYhPT1nKSQuWDM9ZwplbHNlIGY9bnVsbApiPWIuYwppZigoYiYxNSk9PT04KW5ldyBQLlJUKHAsYyxv
+KS4kMCgpCmVsc2UgaWYoaSl7aWYoKGImMSkhPT0wKW5ldyBQLnJxKHAsaikuJDAoKX1lbHNlIGlmKChi
+JjIpIT09MCluZXcgUC5SVyhjLHApLiQwKCkKaWYoZiE9bnVsbCkkLlgzPWYKYj1wLmMKaWYocS5iKGIp
+KXtrPXAuYS4kdGkKaz1rLkMoImI4PDI+IikuYihiKXx8IWsuUVsxXS5iKGIpfWVsc2Ugaz0hMQppZihr
+KXtxLmEoYikKZT1wLmEuYgppZihiIGluc3RhbmNlb2YgUC52cylpZihiLmE+PTQpe2Q9ci5hKGUuYykK
+ZS5jPW51bGwKYTA9ZS5OOChkKQplLmE9Yi5hCmUuYz1iLmMKYy5hPWIKY29udGludWV9ZWxzZSBQLkE5
+KGIsZSkKZWxzZSBlLmVjKGIpCnJldHVybn19ZT1wLmEuYgpkPXIuYShlLmMpCmUuYz1udWxsCmEwPWUu
+TjgoZCkKYj1wLmIKaz1wLmMKaWYoIWIpe2UuJHRpLmMuYShrKQplLmE9NAplLmM9a31lbHNle3MuYShr
+KQplLmE9OAplLmM9a31jLmE9ZQpiPWV9fSwKVkg6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZih0LmFnLmIo
+YSkpcmV0dXJuIGIuTGooYSx0LnosdC5LLHQubCkKcz10LmJJCmlmKHMuYihhKSlyZXR1cm4gcy5hKGEp
+CnRocm93IEguYihQLkwzKGEsIm9uRXJyb3IiLCJFcnJvciBoYW5kbGVyIG11c3QgYWNjZXB0IG9uZSBP
+YmplY3Qgb3Igb25lIE9iamVjdCBhbmQgYSBTdGFja1RyYWNlIGFzIGFyZ3VtZW50cywgYW5kIHJldHVy
+biBhIHZhbGlkIHJlc3VsdCIpKX0sCnB1OmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz0kLlM2O3MhPW51
+bGw7cz0kLlM2KXskLm1nPW51bGwKcj1zLmIKJC5TNj1yCmlmKHI9PW51bGwpJC5rOD1udWxsCnMuYS4k
+MCgpfX0sCmVOOmZ1bmN0aW9uKCl7JC5VRD0hMAp0cnl7UC5wdSgpfWZpbmFsbHl7JC5tZz1udWxsCiQu
+VUQ9ITEKaWYoJC5TNiE9bnVsbCkkLnV0KCkuJDEoUC5VSSgpKX19LAplVzpmdW5jdGlvbihhKXt2YXIg
+cz1uZXcgUC5PTShhKSxyPSQuazgKaWYocj09bnVsbCl7JC5TNj0kLms4PXMKaWYoISQuVUQpJC51dCgp
+LiQxKFAuVUkoKSl9ZWxzZSAkLms4PXIuYj1zfSwKclI6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9JC5T
+NgppZihwPT1udWxsKXtQLmVXKGEpCiQubWc9JC5rOApyZXR1cm59cz1uZXcgUC5PTShhKQpyPSQubWcK
+aWYocj09bnVsbCl7cy5iPXAKJC5TNj0kLm1nPXN9ZWxzZXtxPXIuYgpzLmI9cQokLm1nPXIuYj1zCmlm
+KHE9PW51bGwpJC5rOD1zfX0sCnJiOmZ1bmN0aW9uKGEpe3ZhciBzPW51bGwscj0kLlgzCmlmKEMuTlU9
+PT1yKXtQLlRrKHMscyxDLk5VLGEpCnJldHVybn1QLlRrKHMscyxyLHQuTS5hKHIuR1koYSkpKX0sClF3
+OmZ1bmN0aW9uKGEsYil7SC5jYihhLCJzdHJlYW0iLHQuSykKcmV0dXJuIG5ldyBQLnhJKGIuQygieEk8
+MD4iKSl9LApTaTpmdW5jdGlvbihhLGIpe1AuclIobmV3IFAuRXYoYSxiKSl9LApUODpmdW5jdGlvbihh
+LGIsYyxkLGUpe3ZhciBzLHI9JC5YMwppZihyPT09YylyZXR1cm4gZC4kMCgpCiQuWDM9YwpzPXIKdHJ5
+e3I9ZC4kMCgpCnJldHVybiByfWZpbmFsbHl7JC5YMz1zfX0sCnl2OmZ1bmN0aW9uKGEsYixjLGQsZSxm
+LGcpe3ZhciBzLHI9JC5YMwppZihyPT09YylyZXR1cm4gZC4kMShlKQokLlgzPWMKcz1yCnRyeXtyPWQu
+JDEoZSkKcmV0dXJuIHJ9ZmluYWxseXskLlgzPXN9fSwKUXg6ZnVuY3Rpb24oYSxiLGMsZCxlLGYsZyxo
+LGkpe3ZhciBzLHI9JC5YMwppZihyPT09YylyZXR1cm4gZC4kMihlLGYpCiQuWDM9YwpzPXIKdHJ5e3I9
+ZC4kMihlLGYpCnJldHVybiByfWZpbmFsbHl7JC5YMz1zfX0sClRrOmZ1bmN0aW9uKGEsYixjLGQpe3Qu
+TS5hKGQpCmlmKEMuTlUhPT1jKWQ9Yy5HWShkKQpQLmVXKGQpfSwKdGg6ZnVuY3Rpb24gdGgoYSl7dGhp
+cy5hPWF9LApoYTpmdW5jdGlvbiBoYShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApW
+czpmdW5jdGlvbiBWcyhhKXt0aGlzLmE9YX0sCkZ0OmZ1bmN0aW9uIEZ0KGEpe3RoaXMuYT1hfSwKVzM6
+ZnVuY3Rpb24gVzMoKXt9LAp5SDpmdW5jdGlvbiB5SChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKaWg6
+ZnVuY3Rpb24gaWgoYSxiKXt0aGlzLmE9YQp0aGlzLmI9ITEKdGhpcy4kdGk9Yn0sCldNOmZ1bmN0aW9u
+IFdNKGEpe3RoaXMuYT1hfSwKU1g6ZnVuY3Rpb24gU1goYSl7dGhpcy5hPWF9LApHczpmdW5jdGlvbiBH
+cyhhKXt0aGlzLmE9YX0sCkZ5OmZ1bmN0aW9uIEZ5KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApHVjpm
+dW5jdGlvbiBHVihhLGIpe3ZhciBfPXRoaXMKXy5hPWEKXy5kPV8uYz1fLmI9bnVsbApfLiR0aT1ifSwK
+cTQ6ZnVuY3Rpb24gcTQoYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKQ3c6ZnVuY3Rpb24gQ3coYSxi
+KXt0aGlzLmE9YQp0aGlzLmI9Yn0sClBmOmZ1bmN0aW9uIFBmKCl7fSwKWmY6ZnVuY3Rpb24gWmYoYSxi
+KXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKRmU6ZnVuY3Rpb24gRmUoYSxiLGMsZCxlKXt2YXIgXz10aGlz
+Cl8uYT1udWxsCl8uYj1hCl8uYz1iCl8uZD1jCl8uZT1kCl8uJHRpPWV9LAp2czpmdW5jdGlvbiB2cyhh
+LGIpe3ZhciBfPXRoaXMKXy5hPTAKXy5iPWEKXy5jPW51bGwKXy4kdGk9Yn0sCmRhOmZ1bmN0aW9uIGRh
+KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApvUTpmdW5jdGlvbiBvUShhLGIpe3RoaXMuYT1hCnRoaXMu
+Yj1ifSwKcFY6ZnVuY3Rpb24gcFYoYSl7dGhpcy5hPWF9LApVNzpmdW5jdGlvbiBVNyhhKXt0aGlzLmE9
+YX0sCnZyOmZ1bmN0aW9uIHZyKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCnJ0OmZ1
+bmN0aW9uIHJ0KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApLRjpmdW5jdGlvbiBLRihhLGIpe3RoaXMu
+YT1hCnRoaXMuYj1ifSwKWkw6ZnVuY3Rpb24gWkwoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMu
+Yz1jfSwKUlQ6ZnVuY3Rpb24gUlQoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKalo6
+ZnVuY3Rpb24galooYSl7dGhpcy5hPWF9LApycTpmdW5jdGlvbiBycShhLGIpe3RoaXMuYT1hCnRoaXMu
+Yj1ifSwKUlc6ZnVuY3Rpb24gUlcoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCk9NOmZ1bmN0aW9uIE9N
+KGEpe3RoaXMuYT1hCnRoaXMuYj1udWxsfSwKcWg6ZnVuY3Rpb24gcWgoKXt9LApCNTpmdW5jdGlvbiBC
+NShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKdU86ZnVuY3Rpb24gdU8oYSxiKXt0aGlzLmE9YQp0aGlz
+LmI9Yn0sCk1POmZ1bmN0aW9uIE1PKCl7fSwKa1Q6ZnVuY3Rpb24ga1QoKXt9LAp4STpmdW5jdGlvbiB4
+SShhKXt0aGlzLiR0aT1hfSwKbTA6ZnVuY3Rpb24gbTAoKXt9LApFdjpmdW5jdGlvbiBFdihhLGIpe3Ro
+aXMuYT1hCnRoaXMuYj1ifSwKSmk6ZnVuY3Rpb24gSmkoKXt9LApWcDpmdW5jdGlvbiBWcChhLGIpe3Ro
+aXMuYT1hCnRoaXMuYj1ifSwKT1I6ZnVuY3Rpb24gT1IoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRo
+aXMuYz1jfSwKRUY6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBiLkMoIkA8MD4iKS5LcShjKS5DKCJGbzwx
+LDI+IikuYShILkI3KGEsbmV3IEguTjUoYi5DKCJAPDA+IikuS3EoYykuQygiTjU8MSwyPiIpKSkpfSwK
+Rmw6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguTjUoYS5DKCJAPDA+IikuS3EoYikuQygiTjU8MSwy
+PiIpKX0sCkxzOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5iNihhLkMoImI2PDA+IikpfSwKVDI6ZnVu
+Y3Rpb24oKXt2YXIgcz1PYmplY3QuY3JlYXRlKG51bGwpCnNbIjxub24taWRlbnRpZmllci1rZXk+Il09
+cwpkZWxldGUgc1siPG5vbi1pZGVudGlmaWVyLWtleT4iXQpyZXR1cm4gc30sCnJqOmZ1bmN0aW9uKGEs
+YixjKXt2YXIgcz1uZXcgUC5sbShhLGIsYy5DKCJsbTwwPiIpKQpzLmM9YS5lCnJldHVybiBzfSwKRVA6
+ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKaWYoUC5oQihhKSl7aWYoYj09PSIoIiYmYz09PSIpIilyZXR1
+cm4iKC4uLikiCnJldHVybiBiKyIuLi4iK2N9cz1ILlFJKFtdLHQucykKQy5ObS5pKCQuRixhKQp0cnl7
+UC5WcihhLHMpfWZpbmFsbHl7aWYoMD49JC5GLmxlbmd0aClyZXR1cm4gSC5PSCgkLkYsLTEpCiQuRi5w
+b3AoKX1yPVAubChiLHQudS5hKHMpLCIsICIpK2MKcmV0dXJuIHIuY2hhckNvZGVBdCgwKT09MD9yOnJ9
+LAp4OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCmlmKFAuaEIoYSkpcmV0dXJuIGIrIi4uLiIrYwpzPW5l
+dyBQLk0oYikKQy5ObS5pKCQuRixhKQp0cnl7cj1zCnIuYT1QLmwoci5hLGEsIiwgIil9ZmluYWxseXtp
+ZigwPj0kLkYubGVuZ3RoKXJldHVybiBILk9IKCQuRiwtMSkKJC5GLnBvcCgpfXMuYSs9YwpyPXMuYQpy
+ZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn0sCmhCOmZ1bmN0aW9uKGEpe3ZhciBzLHIKZm9yKHM9
+JC5GLmxlbmd0aCxyPTA7cjxzOysrcilpZihhPT09JC5GW3JdKXJldHVybiEwCnJldHVybiExfSwKVnI6
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsPWEuZ20oYSksaz0wLGo9MAp3aGlsZSghMCl7
+aWYoIShrPDgwfHxqPDMpKWJyZWFrCmlmKCFsLkYoKSlyZXR1cm4Kcz1ILkVqKGwuZ2woKSkKQy5ObS5p
+KGIscykKays9cy5sZW5ndGgrMjsrK2p9aWYoIWwuRigpKXtpZihqPD01KXJldHVybgppZigwPj1iLmxl
+bmd0aClyZXR1cm4gSC5PSChiLC0xKQpyPWIucG9wKCkKaWYoMD49Yi5sZW5ndGgpcmV0dXJuIEguT0go
+YiwtMSkKcT1iLnBvcCgpfWVsc2V7cD1sLmdsKCk7KytqCmlmKCFsLkYoKSl7aWYoajw9NCl7Qy5ObS5p
+KGIsSC5FaihwKSkKcmV0dXJufXI9SC5FaihwKQppZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChiLC0x
+KQpxPWIucG9wKCkKays9ci5sZW5ndGgrMn1lbHNle289bC5nbCgpOysragpmb3IoO2wuRigpO3A9byxv
+PW4pe249bC5nbCgpOysragppZihqPjEwMCl7d2hpbGUoITApe2lmKCEoaz43NSYmaj4zKSlicmVhawpp
+ZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChiLC0xKQprLT1iLnBvcCgpLmxlbmd0aCsyOy0tan1DLk5t
+LmkoYiwiLi4uIikKcmV0dXJufX1xPUguRWoocCkKcj1ILkVqKG8pCmsrPXIubGVuZ3RoK3EubGVuZ3Ro
+KzR9fWlmKGo+Yi5sZW5ndGgrMil7ays9NQptPSIuLi4ifWVsc2UgbT1udWxsCndoaWxlKCEwKXtpZigh
+KGs+ODAmJmIubGVuZ3RoPjMpKWJyZWFrCmlmKDA+PWIubGVuZ3RoKXJldHVybiBILk9IKGIsLTEpCmst
+PWIucG9wKCkubGVuZ3RoKzIKaWYobT09bnVsbCl7ays9NQptPSIuLi4ifX1pZihtIT1udWxsKUMuTm0u
+aShiLG0pCkMuTm0uaShiLHEpCkMuTm0uaShiLHIpfSwKdE06ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9
+UC5McyhiKQpmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDthLmxlbmd0aD09PXN8fCgwLEgubGsp
+KGEpLCsrcilxLmkoMCxiLmEoYVtyXSkpCnJldHVybiBxfSwKbk86ZnVuY3Rpb24oYSl7dmFyIHMscj17
+fQppZihQLmhCKGEpKXJldHVybiJ7Li4ufSIKcz1uZXcgUC5NKCIiKQp0cnl7Qy5ObS5pKCQuRixhKQpz
+LmErPSJ7IgpyLmE9ITAKYS5LKDAsbmV3IFAucmEocixzKSkKcy5hKz0ifSJ9ZmluYWxseXtpZigwPj0k
+LkYubGVuZ3RoKXJldHVybiBILk9IKCQuRiwtMSkKJC5GLnBvcCgpfXI9cy5hCnJldHVybiByLmNoYXJD
+b2RlQXQoMCk9PTA/cjpyfSwKYjY6ZnVuY3Rpb24gYjYoYSl7dmFyIF89dGhpcwpfLmE9MApfLmY9Xy5l
+PV8uZD1fLmM9Xy5iPW51bGwKXy5yPTAKXy4kdGk9YX0sCmJuOmZ1bmN0aW9uIGJuKGEpe3RoaXMuYT1h
+CnRoaXMuYz10aGlzLmI9bnVsbH0sCmxtOmZ1bmN0aW9uIGxtKGEsYixjKXt2YXIgXz10aGlzCl8uYT1h
+Cl8uYj1iCl8uZD1fLmM9bnVsbApfLiR0aT1jfSwKbVc6ZnVuY3Rpb24gbVcoKXt9LAp1eTpmdW5jdGlv
+biB1eSgpe30sCmxEOmZ1bmN0aW9uIGxEKCl7fSwKaWw6ZnVuY3Rpb24gaWwoKXt9LApyYTpmdW5jdGlv
+biByYShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKWWs6ZnVuY3Rpb24gWWsoKXt9LAp5UTpmdW5jdGlv
+biB5UShhKXt0aGlzLmE9YX0sCktQOmZ1bmN0aW9uIEtQKCl7fSwKUG46ZnVuY3Rpb24gUG4oKXt9LApH
+ajpmdW5jdGlvbiBHaihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApsZjpmdW5jdGlvbiBsZigpe30s
+ClZqOmZ1bmN0aW9uIFZqKCl7fSwKWHY6ZnVuY3Rpb24gWHYoKXt9LApuWTpmdW5jdGlvbiBuWSgpe30s
+CldZOmZ1bmN0aW9uIFdZKCl7fSwKUlU6ZnVuY3Rpb24gUlUoKXt9LApwUjpmdW5jdGlvbiBwUigpe30s
+CkJTOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKaWYodHlwZW9mIGEhPSJzdHJpbmciKXRocm93IEgu
+YihILnRMKGEpKQpzPW51bGwKdHJ5e3M9SlNPTi5wYXJzZShhKX1jYXRjaChxKXtyPUguUnUocSkKcD1Q
+LnJyKFN0cmluZyhyKSxudWxsLG51bGwpCnRocm93IEguYihwKX1wPVAuUWUocykKcmV0dXJuIHB9LApR
+ZTpmdW5jdGlvbihhKXt2YXIgcwppZihhPT1udWxsKXJldHVybiBudWxsCmlmKHR5cGVvZiBhIT0ib2Jq
+ZWN0IilyZXR1cm4gYQppZihPYmplY3QuZ2V0UHJvdG90eXBlT2YoYSkhPT1BcnJheS5wcm90b3R5cGUp
+cmV0dXJuIG5ldyBQLnV3KGEsT2JqZWN0LmNyZWF0ZShudWxsKSkKZm9yKHM9MDtzPGEubGVuZ3RoOysr
+cylhW3NdPVAuUWUoYVtzXSkKcmV0dXJuIGF9LApreTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyCmlm
+KGIgaW5zdGFuY2VvZiBVaW50OEFycmF5KXtzPWIKZD1zLmxlbmd0aAppZihkLWM8MTUpcmV0dXJuIG51
+bGwKcj1QLlJQKGEscyxjLGQpCmlmKHIhPW51bGwmJmEpaWYoci5pbmRleE9mKCJcdWZmZmQiKT49MCly
+ZXR1cm4gbnVsbApyZXR1cm4gcn1yZXR1cm4gbnVsbH0sClJQOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBz
+PWE/JC5IRygpOiQucmYoKQppZihzPT1udWxsKXJldHVybiBudWxsCmlmKDA9PT1jJiZkPT09Yi5sZW5n
+dGgpcmV0dXJuIFAuUmIocyxiKQpyZXR1cm4gUC5SYihzLGIuc3ViYXJyYXkoYyxQLmpCKGMsZCxiLmxl
+bmd0aCkpKX0sClJiOmZ1bmN0aW9uKGEsYil7dmFyIHMscgp0cnl7cz1hLmRlY29kZShiKQpyZXR1cm4g
+c31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxsfSwKeE06ZnVuY3Rpb24oYSxiLGMsZCxlLGYpe2lm
+KEMuam4uelkoZiw0KSE9PTApdGhyb3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IHBhZGRpbmcsIHBh
+ZGRlZCBsZW5ndGggbXVzdCBiZSBtdWx0aXBsZSBvZiBmb3VyLCBpcyAiK2YsYSxjKSkKaWYoZCtlIT09
+Zil0aHJvdyBILmIoUC5ycigiSW52YWxpZCBiYXNlNjQgcGFkZGluZywgJz0nIG5vdCBhdCB0aGUgZW5k
+IixhLGIpKQppZihlPjIpdGhyb3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IHBhZGRpbmcsIG1vcmUg
+dGhhbiB0d28gJz0nIGNoYXJhY3RlcnMiLGEsYikpfSwKR3k6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBu
+ZXcgUC5VZChhLGIpfSwKTkM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEuTHQoKX0sClVnOmZ1bmN0aW9uKGEs
+Yil7cmV0dXJuIG5ldyBQLnR1KGEsW10sUC5DeSgpKX0sCnVYOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxy
+PW5ldyBQLk0oIiIpLHE9UC5VZyhyLGIpCnEuaVUoYSkKcz1yLmEKcmV0dXJuIHMuY2hhckNvZGVBdCgw
+KT09MD9zOnN9LApqNDpmdW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSA2NTpyZXR1cm4iTWlzc2luZyBl
+eHRlbnNpb24gYnl0ZSIKY2FzZSA2NzpyZXR1cm4iVW5leHBlY3RlZCBleHRlbnNpb24gYnl0ZSIKY2Fz
+ZSA2OTpyZXR1cm4iSW52YWxpZCBVVEYtOCBieXRlIgpjYXNlIDcxOnJldHVybiJPdmVybG9uZyBlbmNv
+ZGluZyIKY2FzZSA3MzpyZXR1cm4iT3V0IG9mIHVuaWNvZGUgcmFuZ2UiCmNhc2UgNzU6cmV0dXJuIkVu
+Y29kZWQgc3Vycm9nYXRlIgpjYXNlIDc3OnJldHVybiJVbmZpbmlzaGVkIFVURi04IG9jdGV0IHNlcXVl
+bmNlIgpkZWZhdWx0OnJldHVybiIifX0sCmp5OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscD1jLWIs
+bz1uZXcgVWludDhBcnJheShwKQpmb3Iocz1KLlU2KGEpLHI9MDtyPHA7KytyKXtxPXMucShhLGIrcikK
+aWYodHlwZW9mIHEhPT0ibnVtYmVyIilyZXR1cm4gcS56TSgpCmlmKChxJjQyOTQ5NjcwNDApPj4+MCE9
+PTApcT0yNTUKaWYocj49cClyZXR1cm4gSC5PSChvLHIpCm9bcl09cX1yZXR1cm4gb30sCnV3OmZ1bmN0
+aW9uIHV3KGEsYil7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPW51bGx9LAppODpmdW5jdGlvbiBpOChh
+KXt0aGlzLmE9YX0sCnhyOmZ1bmN0aW9uIHhyKCl7fSwKTno6ZnVuY3Rpb24gTnooKXt9LApDVjpmdW5j
+dGlvbiBDVigpe30sClU4OmZ1bmN0aW9uIFU4KCl7fSwKVWs6ZnVuY3Rpb24gVWsoKXt9LAp3STpmdW5j
+dGlvbiB3SSgpe30sClppOmZ1bmN0aW9uIFppKCl7fSwKVWQ6ZnVuY3Rpb24gVWQoYSxiKXt0aGlzLmE9
+YQp0aGlzLmI9Yn0sCks4OmZ1bmN0aW9uIEs4KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApieTpmdW5j
+dGlvbiBieSgpe30sCm9qOmZ1bmN0aW9uIG9qKGEpe3RoaXMuYj1hfSwKTXg6ZnVuY3Rpb24gTXgoYSl7
+dGhpcy5hPWF9LApTaDpmdW5jdGlvbiBTaCgpe30sCnRpOmZ1bmN0aW9uIHRpKGEsYil7dGhpcy5hPWEK
+dGhpcy5iPWJ9LAp0dTpmdW5jdGlvbiB0dShhLGIsYyl7dGhpcy5jPWEKdGhpcy5hPWIKdGhpcy5iPWN9
+LAp1NTpmdW5jdGlvbiB1NSgpe30sCkUzOmZ1bmN0aW9uIEUzKCl7fSwKUnc6ZnVuY3Rpb24gUncoYSl7
+dGhpcy5iPTAKdGhpcy5jPWF9LApHWTpmdW5jdGlvbiBHWShhKXt0aGlzLmE9YX0sCmJ6OmZ1bmN0aW9u
+IGJ6KGEpe3RoaXMuYT1hCnRoaXMuYj0xNgp0aGlzLmM9MH0sClFBOmZ1bmN0aW9uKGEsYil7dmFyIHM9
+SC5IcChhLGIpCmlmKHMhPW51bGwpcmV0dXJuIHMKdGhyb3cgSC5iKFAucnIoYSxudWxsLG51bGwpKX0s
+Cm9zOmZ1bmN0aW9uKGEpe2lmKGEgaW5zdGFuY2VvZiBILlRwKXJldHVybiBhLncoMCkKcmV0dXJuIklu
+c3RhbmNlIG9mICciK0guRWooSC5saChhKSkrIicifSwKTzg6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMs
+cj1jP0ouS2goYSxkKTpKLlFpKGEsZCkKaWYoYSE9PTAmJmIhPW51bGwpZm9yKHM9MDtzPHIubGVuZ3Ro
+OysrcylyW3NdPWIKcmV0dXJuIHJ9LApDSDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscj1ILlFJKFtdLGMu
+QygiamQ8MD4iKSkKZm9yKHM9Si5JVChhKTtzLkYoKTspQy5ObS5pKHIsYy5hKHMuZ2woKSkpCmlmKGIp
+cmV0dXJuIHIKcmV0dXJuIEouRXAocixjKX0sClkxOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihiKXJl
+dHVybiBQLmV2KGEsYykKcz1KLkVwKFAuZXYoYSxjKSxjKQpyZXR1cm4gc30sCmV2OmZ1bmN0aW9uKGEs
+Yil7dmFyIHMscgppZihBcnJheS5pc0FycmF5KGEpKXJldHVybiBILlFJKGEuc2xpY2UoMCksYi5DKCJq
+ZDwwPiIpKQpzPUguUUkoW10sYi5DKCJqZDwwPiIpKQpmb3Iocj1KLklUKGEpO3IuRigpOylDLk5tLmko
+cyxyLmdsKCkpCnJldHVybiBzfSwKQUY6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSi56QyhQLkNIKGEsITEs
+YikpfSwKSE06ZnVuY3Rpb24oYSxiLGMpe2lmKHQuYm0uYihhKSlyZXR1cm4gSC5mdyhhLGIsUC5qQihi
+LGMsYS5sZW5ndGgpKQpyZXR1cm4gUC5idyhhLGIsYyl9LApPbzpmdW5jdGlvbihhKXtyZXR1cm4gSC5M
+dyhhKX0sCmJ3OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvPW51bGwKaWYoYjwwKXRocm93IEgu
+YihQLlRFKGIsMCxhLmxlbmd0aCxvLG8pKQpzPWM9PW51bGwKaWYoIXMmJmM8Yil0aHJvdyBILmIoUC5U
+RShjLGIsYS5sZW5ndGgsbyxvKSkKcj1uZXcgSC5hNyhhLGEubGVuZ3RoLEgueksoYSkuQygiYTc8bEQu
+RT4iKSkKZm9yKHE9MDtxPGI7KytxKWlmKCFyLkYoKSl0aHJvdyBILmIoUC5URShiLDAscSxvLG8pKQpw
+PVtdCmlmKHMpZm9yKDtyLkYoKTspcC5wdXNoKHIuZCkKZWxzZSBmb3IocT1iO3E8YzsrK3Epe2lmKCFy
+LkYoKSl0aHJvdyBILmIoUC5URShjLGIscSxvLG8pKQpwLnB1c2goci5kKX1yZXR1cm4gSC5lVChwKX0s
+Cm51OmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5WUihhLEgudjQoYSwhMSwhMCwhMSwhMSwhMSkpfSwK
+bDpmdW5jdGlvbihhLGIsYyl7dmFyIHM9Si5JVChiKQppZighcy5GKCkpcmV0dXJuIGEKaWYoYy5sZW5n
+dGg9PT0wKXtkbyBhKz1ILkVqKHMuZ2woKSkKd2hpbGUocy5GKCkpfWVsc2V7YSs9SC5FaihzLmdsKCkp
+CmZvcig7cy5GKCk7KWE9YStjK0guRWoocy5nbCgpKX1yZXR1cm4gYX0sCmxyOmZ1bmN0aW9uKGEsYixj
+LGQpe3JldHVybiBuZXcgUC5tcChhLGIsYyxkKX0sCnVvOmZ1bmN0aW9uKCl7dmFyIHM9SC5NMCgpCmlm
+KHMhPW51bGwpcmV0dXJuIFAuaEsocykKdGhyb3cgSC5iKFAuTDQoIidVcmkuYmFzZScgaXMgbm90IHN1
+cHBvcnRlZCIpKX0sCmVQOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG8sbixtPSIwMTIzNDU2
+Nzg5QUJDREVGIgppZihjPT09Qy54TSl7cz0kLno0KCkuYgppZih0eXBlb2YgYiE9InN0cmluZyIpSC52
+KEgudEwoYikpCnM9cy50ZXN0KGIpfWVsc2Ugcz0hMQppZihzKXJldHVybiBiCkguTGgoYykuQygiVWsu
+UyIpLmEoYikKcj1jLmdaRSgpLldKKGIpCmZvcihzPXIubGVuZ3RoLHE9MCxwPSIiO3E8czsrK3Epe289
+cltxXQppZihvPDEyOCl7bj1vPj4+NAppZihuPj04KXJldHVybiBILk9IKGEsbikKbj0oYVtuXSYxPDwo
+byYxNSkpIT09MH1lbHNlIG49ITEKaWYobilwKz1ILkx3KG8pCmVsc2UgcD1kJiZvPT09MzI/cCsiKyI6
+cCsiJSIrbVtvPj4+NCYxNV0rbVtvJjE1XX1yZXR1cm4gcC5jaGFyQ29kZUF0KDApPT0wP3A6cH0sCkdx
+OmZ1bmN0aW9uKGEpe3ZhciBzPU1hdGguYWJzKGEpLHI9YTwwPyItIjoiIgppZihzPj0xMDAwKXJldHVy
+biIiK2EKaWYocz49MTAwKXJldHVybiByKyIwIitzCmlmKHM+PTEwKXJldHVybiByKyIwMCIrcwpyZXR1
+cm4gcisiMDAwIitzfSwKVng6ZnVuY3Rpb24oYSl7aWYoYT49MTAwKXJldHVybiIiK2EKaWYoYT49MTAp
+cmV0dXJuIjAiK2EKcmV0dXJuIjAwIithfSwKaDA6ZnVuY3Rpb24oYSl7aWYoYT49MTApcmV0dXJuIiIr
+YQpyZXR1cm4iMCIrYX0sCmhsOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVtYmVyInx8SC5yUShh
+KXx8YT09bnVsbClyZXR1cm4gSi53KGEpCmlmKHR5cGVvZiBhPT0ic3RyaW5nIilyZXR1cm4gSlNPTi5z
+dHJpbmdpZnkoYSkKcmV0dXJuIFAub3MoYSl9LApoVjpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuQzYo
+YSl9LAp4WTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuYyghMSxudWxsLG51bGwsYSl9LApMMzpmdW5j
+dGlvbihhLGIsYyl7cmV0dXJuIG5ldyBQLmMoITAsYSxiLGMpfSwKTzc6ZnVuY3Rpb24oYSxiKXtyZXR1
+cm4gbmV3IFAuYkoobnVsbCxudWxsLCEwLGEsYiwiVmFsdWUgbm90IGluIHJhbmdlIil9LApURTpmdW5j
+dGlvbihhLGIsYyxkLGUpe3JldHVybiBuZXcgUC5iSihiLGMsITAsYSxkLCJJbnZhbGlkIHZhbHVlIil9
+LAp3QTpmdW5jdGlvbihhLGIsYyxkKXtpZihhPGJ8fGE+Yyl0aHJvdyBILmIoUC5URShhLGIsYyxkLG51
+bGwpKQpyZXR1cm4gYX0sCmpCOmZ1bmN0aW9uKGEsYixjKXtpZigwPmF8fGE+Yyl0aHJvdyBILmIoUC5U
+RShhLDAsYywic3RhcnQiLG51bGwpKQppZihiIT1udWxsKXtpZihhPmJ8fGI+Yyl0aHJvdyBILmIoUC5U
+RShiLGEsYywiZW5kIixudWxsKSkKcmV0dXJuIGJ9cmV0dXJuIGN9LAprMTpmdW5jdGlvbihhLGIpe2lm
+KGE8MCl0aHJvdyBILmIoUC5URShhLDAsbnVsbCxiLG51bGwpKQpyZXR1cm4gYX0sCkNmOmZ1bmN0aW9u
+KGEsYixjLGQsZSl7dmFyIHM9SC51UChlPT1udWxsP0ouSG0oYik6ZSkKcmV0dXJuIG5ldyBQLmVZKHMs
+ITAsYSxjLCJJbmRleCBvdXQgb2YgcmFuZ2UiKX0sCkw0OmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC51
+YihhKX0sClNZOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5kcyhhKX0sClBWOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBuZXcgUC5saihhKX0sCmE0OmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5VVihhKX0sCnJyOmZ1
+bmN0aW9uKGEsYixjKXtyZXR1cm4gbmV3IFAuYUUoYSxiLGMpfSwKaEs6ZnVuY3Rpb24oYTUpe3ZhciBz
+LHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZSxkLGMsYixhLGEwLGExLGEyLGEzPW51bGwsYTQ9YTUu
+bGVuZ3RoCmlmKGE0Pj01KXtzPSgoSi5ReihhNSw0KV41OCkqM3xDLnhCLlcoYTUsMCleMTAwfEMueEIu
+VyhhNSwxKV45N3xDLnhCLlcoYTUsMileMTE2fEMueEIuVyhhNSwzKV45Nyk+Pj4wCmlmKHM9PT0wKXJl
+dHVybiBQLktEKGE0PGE0P0MueEIuTmooYTUsMCxhNCk6YTUsNSxhMykuZ2xSKCkKZWxzZSBpZihzPT09
+MzIpcmV0dXJuIFAuS0QoQy54Qi5OaihhNSw1LGE0KSwwLGEzKS5nbFIoKX1yPVAuTzgoOCwwLCExLHQu
+UykKQy5ObS5ZNShyLDAsMCkKQy5ObS5ZNShyLDEsLTEpCkMuTm0uWTUociwyLC0xKQpDLk5tLlk1KHIs
+NywtMSkKQy5ObS5ZNShyLDMsMCkKQy5ObS5ZNShyLDQsMCkKQy5ObS5ZNShyLDUsYTQpCkMuTm0uWTUo
+ciw2LGE0KQppZihQLlVCKGE1LDAsYTQsMCxyKT49MTQpQy5ObS5ZNShyLDcsYTQpCnE9clsxXQppZihx
+Pj0wKWlmKFAuVUIoYTUsMCxxLDIwLHIpPT09MjApcls3XT1xCnA9clsyXSsxCm89clszXQpuPXJbNF0K
+bT1yWzVdCmw9cls2XQppZihsPG0pbT1sCmlmKG48cCluPW0KZWxzZSBpZihuPD1xKW49cSsxCmlmKG88
+cClvPW4Kaz1yWzddPDAKaWYoaylpZihwPnErMyl7aj1hMwprPSExfWVsc2V7aT1vPjAKaWYoaSYmbysx
+PT09bil7aj1hMwprPSExfWVsc2V7aWYoIShtPGE0JiZtPT09bisyJiZKLnEwKGE1LCIuLiIsbikpKWg9
+bT5uKzImJkoucTAoYTUsIi8uLiIsbS0zKQplbHNlIGg9ITAKaWYoaCl7aj1hMwprPSExfWVsc2V7aWYo
+cT09PTQpaWYoSi5xMChhNSwiZmlsZSIsMCkpe2lmKHA8PTApe2lmKCFDLnhCLlFpKGE1LCIvIixuKSl7
+Zz0iZmlsZTovLy8iCnM9M31lbHNle2c9ImZpbGU6Ly8iCnM9Mn1hNT1nK0MueEIuTmooYTUsbixhNCkK
+cS09MAppPXMtMAptKz1pCmwrPWkKYTQ9YTUubGVuZ3RoCnA9NwpvPTcKbj03fWVsc2UgaWYobj09PW0p
+eysrbApmPW0rMQphNT1DLnhCLmk3KGE1LG4sbSwiLyIpOysrYTQKbT1mfWo9ImZpbGUifWVsc2UgaWYo
+Qy54Qi5RaShhNSwiaHR0cCIsMCkpe2lmKGkmJm8rMz09PW4mJkMueEIuUWkoYTUsIjgwIixvKzEpKXts
+LT0zCmU9bi0zCm0tPTMKYTU9Qy54Qi5pNyhhNSxvLG4sIiIpCmE0LT0zCm49ZX1qPSJodHRwIn1lbHNl
+IGo9YTMKZWxzZSBpZihxPT09NSYmSi5xMChhNSwiaHR0cHMiLDApKXtpZihpJiZvKzQ9PT1uJiZKLnEw
+KGE1LCI0NDMiLG8rMSkpe2wtPTQKZT1uLTQKbS09NAphNT1KLmRnKGE1LG8sbiwiIikKYTQtPTMKbj1l
+fWo9Imh0dHBzIn1lbHNlIGo9YTMKaz0hMH19fWVsc2Ugaj1hMwppZihrKXtpPWE1Lmxlbmd0aAppZihh
+NDxpKXthNT1KLmxkKGE1LDAsYTQpCnEtPTAKcC09MApvLT0wCm4tPTAKbS09MApsLT0wfXJldHVybiBu
+ZXcgUC5VZihhNSxxLHAsbyxuLG0sbCxqKX1pZihqPT1udWxsKWlmKHE+MClqPVAuUGkoYTUsMCxxKQpl
+bHNle2lmKHE9PT0wKXtQLlIzKGE1LDAsIkludmFsaWQgZW1wdHkgc2NoZW1lIikKSC5CaSh1LmcpfWo9
+IiJ9aWYocD4wKXtkPXErMwpjPWQ8cD9QLnpSKGE1LGQscC0xKToiIgpiPVAuT2UoYTUscCxvLCExKQpp
+PW8rMQppZihpPG4pe2E9SC5IcChKLmxkKGE1LGksbiksYTMpCmEwPVAud0IoYT09bnVsbD9ILnYoUC5y
+cigiSW52YWxpZCBwb3J0IixhNSxpKSk6YSxqKX1lbHNlIGEwPWEzfWVsc2V7YTA9YTMKYj1hMApjPSIi
+fWExPVAua2EoYTUsbixtLGEzLGosYiE9bnVsbCkKYTI9bTxsP1AubGUoYTUsbSsxLGwsYTMpOmEzCnJl
+dHVybiBQLkNnKGosYyxiLGEwLGExLGEyLGw8YTQ/UC50RyhhNSxsKzEsYTQpOmEzKX0sCk10OmZ1bmN0
+aW9uKGEpe0guaChhKQpyZXR1cm4gUC5rdShhLDAsYS5sZW5ndGgsQy54TSwhMSl9LApXWDpmdW5jdGlv
+bihhKXt2YXIgcz10Lk4KcmV0dXJuIEMuTm0uTjAoSC5RSShhLnNwbGl0KCImIiksdC5zKSxQLkZsKHMs
+cyksbmV3IFAubjEoQy54TSksdC5KKX0sCkhoOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4s
+bT0iSVB2NCBhZGRyZXNzIHNob3VsZCBjb250YWluIGV4YWN0bHkgNCBwYXJ0cyIsbD0iZWFjaCBwYXJ0
+IG11c3QgYmUgaW4gdGhlIHJhbmdlIDAuLjI1NSIsaz1uZXcgUC5jUyhhKSxqPW5ldyBVaW50OEFycmF5
+KDQpCmZvcihzPWIscj1zLHE9MDtzPGM7KytzKXtwPUMueEIuTyhhLHMpCmlmKHAhPT00Nil7aWYoKHBe
+NDgpPjkpay4kMigiaW52YWxpZCBjaGFyYWN0ZXIiLHMpfWVsc2V7aWYocT09PTMpay4kMihtLHMpCm89
+UC5RQShDLnhCLk5qKGEscixzKSxudWxsKQppZihvPjI1NSlrLiQyKGwscikKbj1xKzEKaWYocT49NCly
+ZXR1cm4gSC5PSChqLHEpCmpbcV09bwpyPXMrMQpxPW59fWlmKHEhPT0zKWsuJDIobSxjKQpvPVAuUUEo
+Qy54Qi5OaihhLHIsYyksbnVsbCkKaWYobz4yNTUpay4kMihsLHIpCmlmKHE+PTQpcmV0dXJuIEguT0go
+aixxKQpqW3FdPW8KcmV0dXJuIGp9LAplZzpmdW5jdGlvbihhLGIsYTApe3ZhciBzLHIscSxwLG8sbixt
+LGwsayxqLGksaCxnLGYsZSxkPW5ldyBQLlZDKGEpLGM9bmV3IFAuSlQoZCxhKQppZihhLmxlbmd0aDwy
+KWQuJDEoImFkZHJlc3MgaXMgdG9vIHNob3J0IikKcz1ILlFJKFtdLHQuYSkKZm9yKHI9YixxPXIscD0h
+MSxvPSExO3I8YTA7KytyKXtuPUMueEIuTyhhLHIpCmlmKG49PT01OCl7aWYocj09PWIpeysrcgppZihD
+LnhCLk8oYSxyKSE9PTU4KWQuJDIoImludmFsaWQgc3RhcnQgY29sb24uIixyKQpxPXJ9aWYocj09PXEp
+e2lmKHApZC4kMigib25seSBvbmUgd2lsZGNhcmQgYDo6YCBpcyBhbGxvd2VkIixyKQpDLk5tLmkocywt
+MSkKcD0hMH1lbHNlIEMuTm0uaShzLGMuJDIocSxyKSkKcT1yKzF9ZWxzZSBpZihuPT09NDYpbz0hMH1p
+ZihzLmxlbmd0aD09PTApZC4kMSgidG9vIGZldyBwYXJ0cyIpCm09cT09PWEwCmw9Qy5ObS5ncloocykK
+aWYobSYmbCE9PS0xKWQuJDIoImV4cGVjdGVkIGEgcGFydCBhZnRlciBsYXN0IGA6YCIsYTApCmlmKCFt
+KWlmKCFvKUMuTm0uaShzLGMuJDIocSxhMCkpCmVsc2V7az1QLkhoKGEscSxhMCkKQy5ObS5pKHMsKGtb
+MF08PDh8a1sxXSk+Pj4wKQpDLk5tLmkocywoa1syXTw8OHxrWzNdKT4+PjApfWlmKHApe2lmKHMubGVu
+Z3RoPjcpZC4kMSgiYW4gYWRkcmVzcyB3aXRoIGEgd2lsZGNhcmQgbXVzdCBoYXZlIGxlc3MgdGhhbiA3
+IHBhcnRzIil9ZWxzZSBpZihzLmxlbmd0aCE9PTgpZC4kMSgiYW4gYWRkcmVzcyB3aXRob3V0IGEgd2ls
+ZGNhcmQgbXVzdCBjb250YWluIGV4YWN0bHkgOCBwYXJ0cyIpCmo9bmV3IFVpbnQ4QXJyYXkoMTYpCmZv
+cihsPXMubGVuZ3RoLGk9OS1sLHI9MCxoPTA7cjxsOysrcil7Zz1zW3JdCmlmKGc9PT0tMSlmb3IoZj0w
+O2Y8aTsrK2Ype2lmKGg8MHx8aD49MTYpcmV0dXJuIEguT0goaixoKQpqW2hdPTAKZT1oKzEKaWYoZT49
+MTYpcmV0dXJuIEguT0goaixlKQpqW2VdPTAKaCs9Mn1lbHNle2U9Qy5qbi53RyhnLDgpCmlmKGg8MHx8
+aD49MTYpcmV0dXJuIEguT0goaixoKQpqW2hdPWUKZT1oKzEKaWYoZT49MTYpcmV0dXJuIEguT0goaixl
+KQpqW2VdPWcmMjU1CmgrPTJ9fXJldHVybiBqfSwKQ2c6ZnVuY3Rpb24oYSxiLGMsZCxlLGYsZyl7cmV0
+dXJuIG5ldyBQLkRuKGEsYixjLGQsZSxmLGcpfSwKS0w6ZnVuY3Rpb24oYSxiLGMsZCxlLGYsZyl7dmFy
+IHMscixxLHAsbyxuCmY9Zj09bnVsbD8iIjpQLlBpKGYsMCxmLmxlbmd0aCkKZz1QLnpSKGcsMCxnPT1u
+dWxsPzA6Zy5sZW5ndGgpCmE9UC5PZShhLDAsYT09bnVsbD8wOmEubGVuZ3RoLCExKQpzPVAubGUobnVs
+bCwwLDAsZSkKcj1QLnRHKG51bGwsMCwwKQpkPVAud0IoZCxmKQpxPWY9PT0iZmlsZSIKaWYoYT09bnVs
+bClwPWcubGVuZ3RoIT09MHx8ZCE9bnVsbHx8cQplbHNlIHA9ITEKaWYocClhPSIiCnA9YT09bnVsbApv
+PSFwCmI9UC5rYShiLDAsYj09bnVsbD8wOmIubGVuZ3RoLGMsZixvKQpuPWYubGVuZ3RoPT09MAppZihu
+JiZwJiYhQy54Qi5uQyhiLCIvIikpYj1QLndGKGIsIW58fG8pCmVsc2UgYj1QLnhlKGIpCnJldHVybiBQ
+LkNnKGYsZyxwJiZDLnhCLm5DKGIsIi8vIik/IiI6YSxkLGIscyxyKX0sCndLOmZ1bmN0aW9uKGEpe2lm
+KGE9PT0iaHR0cCIpcmV0dXJuIDgwCmlmKGE9PT0iaHR0cHMiKXJldHVybiA0NDMKcmV0dXJuIDB9LApO
+UjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbgpmb3Iocz1hLmxlbmd0aCxyPTA7cjxzOysrcil7
+cT1DLnhCLlcoYSxyKQpwPUMueEIuVyhiLHIpCm89cV5wCmlmKG8hPT0wKXtpZihvPT09MzIpe249cHxv
+CmlmKDk3PD1uJiZuPD0xMjIpY29udGludWV9cmV0dXJuITF9fXJldHVybiEwfSwKUjM6ZnVuY3Rpb24o
+YSxiLGMpe3Rocm93IEguYihQLnJyKGMsYSxiKSl9LApYZDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxy
+LHEscCxvLG4sbSxsLGssaixpLGg9bnVsbCxnPWIubGVuZ3RoCmlmKGchPT0wKXtxPTAKd2hpbGUoITAp
+e2lmKCEocTxnKSl7cz0iIgpyPTAKYnJlYWt9aWYoQy54Qi5XKGIscSk9PT02NCl7cz1DLnhCLk5qKGIs
+MCxxKQpyPXErMQpicmVha30rK3F9aWYocjxnJiZDLnhCLlcoYixyKT09PTkxKXtmb3IocD1yLG89LTE7
+cDxnOysrcCl7bj1DLnhCLlcoYixwKQppZihuPT09MzcmJm88MCl7bT1DLnhCLlFpKGIsIjI1IixwKzEp
+P3ArMjpwCm89cApwPW19ZWxzZSBpZihuPT09OTMpYnJlYWt9aWYocD09PWcpdGhyb3cgSC5iKFAucnIo
+IkludmFsaWQgSVB2NiBob3N0IGVudHJ5LiIsYixyKSkKbD1vPDA/cDpvClAuZWcoYixyKzEsbCk7Kytw
+CmlmKHAhPT1nJiZDLnhCLlcoYixwKSE9PTU4KXRocm93IEguYihQLnJyKCJJbnZhbGlkIGVuZCBvZiBh
+dXRob3JpdHkiLGIscCkpfWVsc2UgcD1yCndoaWxlKCEwKXtpZighKHA8Zykpe2s9aApicmVha31pZihD
+LnhCLlcoYixwKT09PTU4KXtqPUMueEIueW4oYixwKzEpCms9ai5sZW5ndGghPT0wP1AuUUEoaixoKTpo
+CmJyZWFrfSsrcH1pPUMueEIuTmooYixyLHApfWVsc2V7az1oCmk9awpzPSIifXJldHVybiBQLktMKGks
+aCxILlFJKGMuc3BsaXQoIi8iKSx0LnMpLGssZCxhLHMpfSwKa0U6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
+CmZvcihzPUouSVQoYSk7cy5GKCk7KXtyPXMuZ2woKQpyLnRvU3RyaW5nCmlmKEguU1EociwiLyIsMCkp
+e3M9UC5MNCgiSWxsZWdhbCBwYXRoIGNoYXJhY3RlciAiK3IpCnRocm93IEguYihzKX19fSwKSE46ZnVu
+Y3Rpb24oYSxiLGMpe3ZhciBzLHIscQpmb3Iocz1KLkE1KGEsYykscz1zLmdtKHMpO3MuRigpOyl7cj1z
+LmdsKCkKcT1QLm51KCdbIiovOjw+P1xcXFx8XScpCnIudG9TdHJpbmcKaWYoSC5TUShyLHEsMCkpe3M9
+UC5MNCgiSWxsZWdhbCBjaGFyYWN0ZXIgaW4gcGF0aDogIityKQp0aHJvdyBILmIocyl9fX0sCnJnOmZ1
+bmN0aW9uKGEsYil7dmFyIHMKaWYoISg2NTw9YSYmYTw9OTApKXM9OTc8PWEmJmE8PTEyMgplbHNlIHM9
+ITAKaWYocylyZXR1cm4Kcz1QLkw0KCJJbGxlZ2FsIGRyaXZlIGxldHRlciAiK1AuT28oYSkpCnRocm93
+IEguYihzKX0sCndCOmZ1bmN0aW9uKGEsYil7aWYoYSE9bnVsbCYmYT09PVAud0soYikpcmV0dXJuIG51
+bGwKcmV0dXJuIGF9LApPZTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4KaWYoYT09bnVs
+bClyZXR1cm4gbnVsbAppZihiPT09YylyZXR1cm4iIgppZihDLnhCLk8oYSxiKT09PTkxKXtzPWMtMQpp
+ZihDLnhCLk8oYSxzKSE9PTkzKXtQLlIzKGEsYiwiTWlzc2luZyBlbmQgYF1gIHRvIG1hdGNoIGBbYCBp
+biBob3N0IikKSC5CaSh1LmcpfXI9YisxCnE9UC50byhhLHIscykKaWYocTxzKXtwPXErMQpvPVAuT0Eo
+YSxDLnhCLlFpKGEsIjI1IixwKT9xKzM6cCxzLCIlMjUiKX1lbHNlIG89IiIKUC5lZyhhLHIscSkKcmV0
+dXJuIEMueEIuTmooYSxiLHEpLnRvTG93ZXJDYXNlKCkrbysiXSJ9Zm9yKG49YjtuPGM7KytuKWlmKEMu
+eEIuTyhhLG4pPT09NTgpe3E9Qy54Qi5YVShhLCIlIixiKQpxPXE+PWImJnE8Yz9xOmMKaWYocTxjKXtw
+PXErMQpvPVAuT0EoYSxDLnhCLlFpKGEsIjI1IixwKT9xKzM6cCxjLCIlMjUiKX1lbHNlIG89IiIKUC5l
+ZyhhLGIscSkKcmV0dXJuIlsiK0MueEIuTmooYSxiLHEpK28rIl0ifXJldHVybiBQLk9MKGEsYixjKX0s
+CnRvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1DLnhCLlhVKGEsIiUiLGIpCnJldHVybiBzPj1iJiZzPGM/
+czpjfSwKT0E6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT1kIT09IiI/
+bmV3IFAuTShkKTpudWxsCmZvcihzPWIscj1zLHE9ITA7czxjOyl7cD1DLnhCLk8oYSxzKQppZihwPT09
+Mzcpe289UC5ydihhLHMsITApCm49bz09bnVsbAppZihuJiZxKXtzKz0zCmNvbnRpbnVlfWlmKGk9PW51
+bGwpaT1uZXcgUC5NKCIiKQptPWkuYSs9Qy54Qi5OaihhLHIscykKaWYobilvPUMueEIuTmooYSxzLHMr
+MykKZWxzZSBpZihvPT09IiUiKXtQLlIzKGEscywiWm9uZUlEIHNob3VsZCBub3QgY29udGFpbiAlIGFu
+eW1vcmUiKQpILkJpKHUuZyl9aS5hPW0rbwpzKz0zCnI9cwpxPSEwfWVsc2V7aWYocDwxMjcpe249cD4+
+PjQKaWYobj49OClyZXR1cm4gSC5PSChDLkYzLG4pCm49KEMuRjNbbl0mMTw8KHAmMTUpKSE9PTB9ZWxz
+ZSBuPSExCmlmKG4pe2lmKHEmJjY1PD1wJiY5MD49cCl7aWYoaT09bnVsbClpPW5ldyBQLk0oIiIpCmlm
+KHI8cyl7aS5hKz1DLnhCLk5qKGEscixzKQpyPXN9cT0hMX0rK3N9ZWxzZXtpZigocCY2NDUxMik9PT01
+NTI5NiYmcysxPGMpe2w9Qy54Qi5PKGEscysxKQppZigobCY2NDUxMik9PT01NjMyMCl7cD0ocCYxMDIz
+KTw8MTB8bCYxMDIzfDY1NTM2Cms9Mn1lbHNlIGs9MX1lbHNlIGs9MQpqPUMueEIuTmooYSxyLHMpCmlm
+KGk9PW51bGwpe2k9bmV3IFAuTSgiIikKbj1pfWVsc2Ugbj1pCm4uYSs9agpuLmErPVAuelgocCkKcys9
+awpyPXN9fX1pZihpPT1udWxsKXJldHVybiBDLnhCLk5qKGEsYixjKQppZihyPGMpaS5hKz1DLnhCLk5q
+KGEscixjKQpuPWkuYQpyZXR1cm4gbi5jaGFyQ29kZUF0KDApPT0wP246bn0sCk9MOmZ1bmN0aW9uKGEs
+YixjKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpCmZvcihzPWIscj1zLHE9bnVsbCxwPSEwO3M8Yzsp
+e289Qy54Qi5PKGEscykKaWYobz09PTM3KXtuPVAucnYoYSxzLCEwKQptPW49PW51bGwKaWYobSYmcCl7
+cys9Mwpjb250aW51ZX1pZihxPT1udWxsKXE9bmV3IFAuTSgiIikKbD1DLnhCLk5qKGEscixzKQprPXEu
+YSs9IXA/bC50b0xvd2VyQ2FzZSgpOmwKaWYobSl7bj1DLnhCLk5qKGEscyxzKzMpCmo9M31lbHNlIGlm
+KG49PT0iJSIpe249IiUyNSIKaj0xfWVsc2Ugaj0zCnEuYT1rK24Kcys9agpyPXMKcD0hMH1lbHNle2lm
+KG88MTI3KXttPW8+Pj40CmlmKG0+PTgpcmV0dXJuIEguT0goQy5lYSxtKQptPShDLmVhW21dJjE8PChv
+JjE1KSkhPT0wfWVsc2UgbT0hMQppZihtKXtpZihwJiY2NTw9byYmOTA+PW8pe2lmKHE9PW51bGwpcT1u
+ZXcgUC5NKCIiKQppZihyPHMpe3EuYSs9Qy54Qi5OaihhLHIscykKcj1zfXA9ITF9KytzfWVsc2V7aWYo
+bzw9OTMpe209bz4+PjQKaWYobT49OClyZXR1cm4gSC5PSChDLmFrLG0pCm09KEMuYWtbbV0mMTw8KG8m
+MTUpKSE9PTB9ZWxzZSBtPSExCmlmKG0pe1AuUjMoYSxzLCJJbnZhbGlkIGNoYXJhY3RlciIpCkguQmko
+dS5nKX1lbHNle2lmKChvJjY0NTEyKT09PTU1Mjk2JiZzKzE8Yyl7aT1DLnhCLk8oYSxzKzEpCmlmKChp
+JjY0NTEyKT09PTU2MzIwKXtvPShvJjEwMjMpPDwxMHxpJjEwMjN8NjU1MzYKaj0yfWVsc2Ugaj0xfWVs
+c2Ugaj0xCmw9Qy54Qi5OaihhLHIscykKaWYoIXApbD1sLnRvTG93ZXJDYXNlKCkKaWYocT09bnVsbCl7
+cT1uZXcgUC5NKCIiKQptPXF9ZWxzZSBtPXEKbS5hKz1sCm0uYSs9UC56WChvKQpzKz1qCnI9c319fX1p
+ZihxPT1udWxsKXJldHVybiBDLnhCLk5qKGEsYixjKQppZihyPGMpe2w9Qy54Qi5OaihhLHIsYykKcS5h
+Kz0hcD9sLnRvTG93ZXJDYXNlKCk6bH1tPXEuYQpyZXR1cm4gbS5jaGFyQ29kZUF0KDApPT0wP206bX0s
+ClBpOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvPXUuZwppZihiPT09YylyZXR1cm4iIgppZigh
+UC5FdChKLlF6KGEsYikpKXtQLlIzKGEsYiwiU2NoZW1lIG5vdCBzdGFydGluZyB3aXRoIGFscGhhYmV0
+aWMgY2hhcmFjdGVyIikKSC5CaShvKX1mb3Iocz1iLHI9ITE7czxjOysrcyl7cT1DLnhCLlcoYSxzKQpp
+ZihxPDEyOCl7cD1xPj4+NAppZihwPj04KXJldHVybiBILk9IKEMubUsscCkKcD0oQy5tS1twXSYxPDwo
+cSYxNSkpIT09MH1lbHNlIHA9ITEKaWYoIXApe1AuUjMoYSxzLCJJbGxlZ2FsIHNjaGVtZSBjaGFyYWN0
+ZXIiKQpILkJpKG8pfWlmKDY1PD1xJiZxPD05MClyPSEwfWE9Qy54Qi5OaihhLGIsYykKcmV0dXJuIFAu
+WWEocj9hLnRvTG93ZXJDYXNlKCk6YSl9LApZYTpmdW5jdGlvbihhKXtpZihhPT09Imh0dHAiKXJldHVy
+biJodHRwIgppZihhPT09ImZpbGUiKXJldHVybiJmaWxlIgppZihhPT09Imh0dHBzIilyZXR1cm4iaHR0
+cHMiCmlmKGE9PT0icGFja2FnZSIpcmV0dXJuInBhY2thZ2UiCnJldHVybiBhfSwKelI6ZnVuY3Rpb24o
+YSxiLGMpe2lmKGE9PW51bGwpcmV0dXJuIiIKcmV0dXJuIFAuUEkoYSxiLGMsQy50bywhMSl9LAprYTpm
+dW5jdGlvbihhLGIsYyxkLGUsZil7dmFyIHMscixxPWU9PT0iZmlsZSIscD1xfHxmCmlmKGE9PW51bGwp
+e2lmKGQ9PW51bGwpcmV0dXJuIHE/Ii8iOiIiCnM9SC50NihkKQpyPW5ldyBILmxKKGQscy5DKCJxVSgx
+KSIpLmEobmV3IFAuUlooKSkscy5DKCJsSjwxLHFVPiIpKS5rKDAsIi8iKX1lbHNlIGlmKGQhPW51bGwp
+dGhyb3cgSC5iKFAueFkoIkJvdGggcGF0aCBhbmQgcGF0aFNlZ21lbnRzIHNwZWNpZmllZCIpKQplbHNl
+IHI9UC5QSShhLGIsYyxDLldkLCEwKQppZihyLmxlbmd0aD09PTApe2lmKHEpcmV0dXJuIi8ifWVsc2Ug
+aWYocCYmIUMueEIubkMociwiLyIpKXI9Ii8iK3IKcmV0dXJuIFAuSnIocixlLGYpfSwKSnI6ZnVuY3Rp
+b24oYSxiLGMpe3ZhciBzPWIubGVuZ3RoPT09MAppZihzJiYhYyYmIUMueEIubkMoYSwiLyIpKXJldHVy
+biBQLndGKGEsIXN8fGMpCnJldHVybiBQLnhlKGEpfSwKbGU6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMs
+cj17fQppZihhIT1udWxsKXtpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJCb3RoIHF1ZXJ5IGFuZCBx
+dWVyeVBhcmFtZXRlcnMgc3BlY2lmaWVkIikpCnJldHVybiBQLlBJKGEsYixjLEMuVkMsITApfWlmKGQ9
+PW51bGwpcmV0dXJuIG51bGwKcz1uZXcgUC5NKCIiKQpyLmE9IiIKZC5LKDAsbmV3IFAueTUobmV3IFAu
+TUUocixzKSkpCnI9cy5hCnJldHVybiByLmNoYXJDb2RlQXQoMCk9PTA/cjpyfSwKdEc6ZnVuY3Rpb24o
+YSxiLGMpe2lmKGE9PW51bGwpcmV0dXJuIG51bGwKcmV0dXJuIFAuUEkoYSxiLGMsQy5WQywhMCl9LApy
+djpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuPWIrMgppZihuPj1hLmxlbmd0aClyZXR1cm4i
+JSIKcz1DLnhCLk8oYSxiKzEpCnI9Qy54Qi5PKGEsbikKcT1ILm9vKHMpCnA9SC5vbyhyKQppZihxPDB8
+fHA8MClyZXR1cm4iJSIKbz1xKjE2K3AKaWYobzwxMjcpe249Qy5qbi53RyhvLDQpCmlmKG4+PTgpcmV0
+dXJuIEguT0goQy5GMyxuKQpuPShDLkYzW25dJjE8PChvJjE1KSkhPT0wfWVsc2Ugbj0hMQppZihuKXJl
+dHVybiBILkx3KGMmJjY1PD1vJiY5MD49bz8ob3wzMik+Pj4wOm8pCmlmKHM+PTk3fHxyPj05NylyZXR1
+cm4gQy54Qi5OaihhLGIsYiszKS50b1VwcGVyQ2FzZSgpCnJldHVybiBudWxsfSwKelg6ZnVuY3Rpb24o
+YSl7dmFyIHMscixxLHAsbyxuLG0sbCxrPSIwMTIzNDU2Nzg5QUJDREVGIgppZihhPDEyOCl7cz1uZXcg
+VWludDhBcnJheSgzKQpzWzBdPTM3CnNbMV09Qy54Qi5XKGssYT4+PjQpCnNbMl09Qy54Qi5XKGssYSYx
+NSl9ZWxzZXtpZihhPjIwNDcpaWYoYT42NTUzNSl7cj0yNDAKcT00fWVsc2V7cj0yMjQKcT0zfWVsc2V7
+cj0xOTIKcT0yfXA9MypxCnM9bmV3IFVpbnQ4QXJyYXkocCkKZm9yKG89MDstLXEscT49MDtyPTEyOCl7
+bj1DLmpuLmJmKGEsNipxKSY2M3xyCmlmKG8+PXApcmV0dXJuIEguT0gocyxvKQpzW29dPTM3Cm09bysx
+Cmw9Qy54Qi5XKGssbj4+PjQpCmlmKG0+PXApcmV0dXJuIEguT0gocyxtKQpzW21dPWwKbD1vKzIKbT1D
+LnhCLlcoayxuJjE1KQppZihsPj1wKXJldHVybiBILk9IKHMsbCkKc1tsXT1tCm8rPTN9fXJldHVybiBQ
+LkhNKHMsMCxudWxsKX0sClBJOmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHM9UC5VbChhLGIsYyxkLGUp
+CnJldHVybiBzPT1udWxsP0MueEIuTmooYSxiLGMpOnN9LApVbDpmdW5jdGlvbihhLGIsYyxkLGUpe3Zh
+ciBzLHIscSxwLG8sbixtLGwsayxqPW51bGwKZm9yKHM9IWUscj1iLHE9cixwPWo7cjxjOyl7bz1DLnhC
+Lk8oYSxyKQppZihvPDEyNyl7bj1vPj4+NAppZihuPj04KXJldHVybiBILk9IKGQsbikKbj0oZFtuXSYx
+PDwobyYxNSkpIT09MH1lbHNlIG49ITEKaWYobikrK3IKZWxzZXtpZihvPT09Mzcpe209UC5ydihhLHIs
+ITEpCmlmKG09PW51bGwpe3IrPTMKY29udGludWV9aWYoIiUiPT09bSl7bT0iJTI1IgpsPTF9ZWxzZSBs
+PTN9ZWxzZXtpZihzKWlmKG88PTkzKXtuPW8+Pj40CmlmKG4+PTgpcmV0dXJuIEguT0goQy5hayxuKQpu
+PShDLmFrW25dJjE8PChvJjE1KSkhPT0wfWVsc2Ugbj0hMQplbHNlIG49ITEKaWYobil7UC5SMyhhLHIs
+IkludmFsaWQgY2hhcmFjdGVyIikKSC5CaSh1LmcpCmw9agptPWx9ZWxzZXtpZigobyY2NDUxMik9PT01
+NTI5Nil7bj1yKzEKaWYobjxjKXtrPUMueEIuTyhhLG4pCmlmKChrJjY0NTEyKT09PTU2MzIwKXtvPShv
+JjEwMjMpPDwxMHxrJjEwMjN8NjU1MzYKbD0yfWVsc2UgbD0xfWVsc2UgbD0xfWVsc2UgbD0xCm09UC56
+WChvKX19aWYocD09bnVsbCl7cD1uZXcgUC5NKCIiKQpuPXB9ZWxzZSBuPXAKbi5hKz1DLnhCLk5qKGEs
+cSxyKQpuLmErPUguRWoobSkKaWYodHlwZW9mIGwhPT0ibnVtYmVyIilyZXR1cm4gSC5wWShsKQpyKz1s
+CnE9cn19aWYocD09bnVsbClyZXR1cm4gagppZihxPGMpcC5hKz1DLnhCLk5qKGEscSxjKQpzPXAuYQpy
+ZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c30sCnlCOmZ1bmN0aW9uKGEpe2lmKEMueEIubkMoYSwi
+LiIpKXJldHVybiEwCnJldHVybiBDLnhCLk9ZKGEsIi8uIikhPT0tMX0sCnhlOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHIscSxwLG8sbixtCmlmKCFQLnlCKGEpKXJldHVybiBhCnM9SC5RSShbXSx0LnMpCmZvcihyPWEu
+c3BsaXQoIi8iKSxxPXIubGVuZ3RoLHA9ITEsbz0wO288cTsrK28pe249cltvXQppZihKLlJNKG4sIi4u
+Iikpe209cy5sZW5ndGgKaWYobSE9PTApe2lmKDA+PW0pcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpp
+ZihzLmxlbmd0aD09PTApQy5ObS5pKHMsIiIpfXA9ITB9ZWxzZSBpZigiLiI9PT1uKXA9ITAKZWxzZXtD
+Lk5tLmkocyxuKQpwPSExfX1pZihwKUMuTm0uaShzLCIiKQpyZXR1cm4gQy5ObS5rKHMsIi8iKX0sCndG
+OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuCmlmKCFQLnlCKGEpKXJldHVybiFiP1AuQzEoYSk6
+YQpzPUguUUkoW10sdC5zKQpmb3Iocj1hLnNwbGl0KCIvIikscT1yLmxlbmd0aCxwPSExLG89MDtvPHE7
+KytvKXtuPXJbb10KaWYoIi4uIj09PW4paWYocy5sZW5ndGghPT0wJiZDLk5tLmdyWihzKSE9PSIuLiIp
+e2lmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcD0hMH1lbHNle0MuTm0uaShz
+LCIuLiIpCnA9ITF9ZWxzZSBpZigiLiI9PT1uKXA9ITAKZWxzZXtDLk5tLmkocyxuKQpwPSExfX1yPXMu
+bGVuZ3RoCmlmKHIhPT0wKWlmKHI9PT0xKXtpZigwPj1yKXJldHVybiBILk9IKHMsMCkKcj1zWzBdLmxl
+bmd0aD09PTB9ZWxzZSByPSExCmVsc2Ugcj0hMAppZihyKXJldHVybiIuLyIKaWYocHx8Qy5ObS5ncloo
+cyk9PT0iLi4iKUMuTm0uaShzLCIiKQppZighYil7aWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocyww
+KQpDLk5tLlk1KHMsMCxQLkMxKHNbMF0pKX1yZXR1cm4gQy5ObS5rKHMsIi8iKX0sCkMxOmZ1bmN0aW9u
+KGEpe3ZhciBzLHIscSxwPWEubGVuZ3RoCmlmKHA+PTImJlAuRXQoSi5ReihhLDApKSlmb3Iocz0xO3M8
+cDsrK3Mpe3I9Qy54Qi5XKGEscykKaWYocj09PTU4KXJldHVybiBDLnhCLk5qKGEsMCxzKSsiJTNBIitD
+LnhCLnluKGEscysxKQppZihyPD0xMjcpe3E9cj4+PjQKaWYocT49OClyZXR1cm4gSC5PSChDLm1LLHEp
+CnE9KEMubUtbcV0mMTw8KHImMTUpKT09PTB9ZWxzZSBxPSEwCmlmKHEpYnJlYWt9cmV0dXJuIGF9LAp1
+ajpmdW5jdGlvbihhLGIpe2lmKGEuaEIoInBhY2thZ2UiKSYmYS5jPT1udWxsKXJldHVybiBQLmZGKGIs
+MCxiLmxlbmd0aCkKcmV0dXJuLTF9LAptbjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLmdGaigpLG89
+Si5VNihwKQppZihvLmdBKHApPjAmJkouSG0oby5xKHAsMCkpPT09MiYmSi5hNihvLnEocCwwKSwxKT09
+PTU4KXtQLnJnKEouYTYoby5xKHAsMCksMCksITEpClAuSE4ocCwhMSwxKQpzPSEwfWVsc2V7UC5ITihw
+LCExLDApCnM9ITF9cj1hLmd0VCgpJiYhcz8iXFwiOiIiCmlmKGEuZ2NqKCkpe3E9YS5nSmYoYSkKaWYo
+cS5sZW5ndGghPT0wKXI9cisiXFwiK3ErIlxcIn1yPVAubChyLHAsIlxcIikKbz1zJiZvLmdBKHApPT09
+MT9yKyJcXCI6cgpyZXR1cm4gby5jaGFyQ29kZUF0KDApPT0wP286b30sCkloOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxCmZvcihzPTAscj0wO3I8MjsrK3Ipe3E9Qy54Qi5XKGEsYityKQppZig0ODw9cSYmcTw9
+NTcpcz1zKjE2K3EtNDgKZWxzZXtxfD0zMgppZig5Nzw9cSYmcTw9MTAyKXM9cyoxNitxLTg3CmVsc2Ug
+dGhyb3cgSC5iKFAueFkoIkludmFsaWQgVVJMIGVuY29kaW5nIikpfX1yZXR1cm4gc30sCmt1OmZ1bmN0
+aW9uKGEsYixjLGQsZSl7dmFyIHMscixxLHAsbz1KLnJZKGEpLG49Ygp3aGlsZSghMCl7aWYoIShuPGMp
+KXtzPSEwCmJyZWFrfXI9by5XKGEsbikKaWYocjw9MTI3KWlmKHIhPT0zNylxPWUmJnI9PT00MwplbHNl
+IHE9ITAKZWxzZSBxPSEwCmlmKHEpe3M9ITEKYnJlYWt9KytufWlmKHMpe2lmKEMueE0hPT1kKXE9ITEK
+ZWxzZSBxPSEwCmlmKHEpcmV0dXJuIG8uTmooYSxiLGMpCmVsc2UgcD1uZXcgSC5xaihvLk5qKGEsYixj
+KSl9ZWxzZXtwPUguUUkoW10sdC5hKQpmb3Iobj1iO248YzsrK24pe3I9by5XKGEsbikKaWYocj4xMjcp
+dGhyb3cgSC5iKFAueFkoIklsbGVnYWwgcGVyY2VudCBlbmNvZGluZyBpbiBVUkkiKSkKaWYocj09PTM3
+KXtpZihuKzM+YS5sZW5ndGgpdGhyb3cgSC5iKFAueFkoIlRydW5jYXRlZCBVUkkiKSkKQy5ObS5pKHAs
+UC5JaChhLG4rMSkpCm4rPTJ9ZWxzZSBpZihlJiZyPT09NDMpQy5ObS5pKHAsMzIpCmVsc2UgQy5ObS5p
+KHAscil9fXQuTC5hKHApCnJldHVybiBDLm9FLldKKHApfSwKRXQ6ZnVuY3Rpb24oYSl7dmFyIHM9YXwz
+MgpyZXR1cm4gOTc8PXMmJnM8PTEyMn0sCktEOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4s
+bSxsLGs9IkludmFsaWQgTUlNRSB0eXBlIixqPUguUUkoW2ItMV0sdC5hKQpmb3Iocz1hLmxlbmd0aCxy
+PWIscT0tMSxwPW51bGw7cjxzOysrcil7cD1DLnhCLlcoYSxyKQppZihwPT09NDR8fHA9PT01OSlicmVh
+awppZihwPT09NDcpe2lmKHE8MCl7cT1yCmNvbnRpbnVlfXRocm93IEguYihQLnJyKGssYSxyKSl9fWlm
+KHE8MCYmcj5iKXRocm93IEguYihQLnJyKGssYSxyKSkKZm9yKDtwIT09NDQ7KXtDLk5tLmkoaixyKTsr
+K3IKZm9yKG89LTE7cjxzOysrcil7cD1DLnhCLlcoYSxyKQppZihwPT09NjEpe2lmKG88MClvPXJ9ZWxz
+ZSBpZihwPT09NTl8fHA9PT00NClicmVha31pZihvPj0wKUMuTm0uaShqLG8pCmVsc2V7bj1DLk5tLmdy
+WihqKQppZihwIT09NDR8fHIhPT1uKzd8fCFDLnhCLlFpKGEsImJhc2U2NCIsbisxKSl0aHJvdyBILmIo
+UC5ycigiRXhwZWN0aW5nICc9JyIsYSxyKSkKYnJlYWt9fUMuTm0uaShqLHIpCm09cisxCmlmKChqLmxl
+bmd0aCYxKT09PTEpYT1DLmg5LnlyKGEsbSxzKQplbHNle2w9UC5VbChhLG0scyxDLlZDLCEwKQppZihs
+IT1udWxsKWE9Qy54Qi5pNyhhLG0scyxsKX1yZXR1cm4gbmV3IFAuUEUoYSxqLGMpfSwKS046ZnVuY3Rp
+b24oKXt2YXIgcyxyLHEscCxvLG4sbT0iMDEyMzQ1Njc4OUFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFla
+YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXotLl9+ISQmJygpKissOz0iLGw9Ii4iLGs9IjoiLGo9Ii8i
+LGk9Ij8iLGg9IiMiLGc9SC5RSShuZXcgQXJyYXkoMjIpLHQuZ04pCmZvcihzPTA7czwyMjsrK3MpZ1tz
+XT1uZXcgVWludDhBcnJheSg5NikKcj1uZXcgUC55SShnKQpxPW5ldyBQLmM2KCkKcD1uZXcgUC5xZCgp
+Cm89dC5nYwpuPW8uYShyLiQyKDAsMjI1KSkKcS4kMyhuLG0sMSkKcS4kMyhuLGwsMTQpCnEuJDMobixr
+LDM0KQpxLiQzKG4saiwzKQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxNCwy
+MjUpKQpxLiQzKG4sbSwxKQpxLiQzKG4sbCwxNSkKcS4kMyhuLGssMzQpCnEuJDMobixqLDIzNCkKcS4k
+MyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTUsMjI1KSkKcS4kMyhuLG0sMSkKcS4k
+MyhuLCIlIiwyMjUpCnEuJDMobixrLDM0KQpxLiQzKG4saiw5KQpxLiQzKG4saSwxNzIpCnEuJDMobixo
+LDIwNSkKbj1vLmEoci4kMigxLDIyNSkpCnEuJDMobixtLDEpCnEuJDMobixrLDM0KQpxLiQzKG4saiwx
+MCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMiwyMzUpKQpxLiQzKG4sbSwx
+MzkpCnEuJDMobixqLDEzMSkKcS4kMyhuLGwsMTQ2KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkK
+bj1vLmEoci4kMigzLDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiw2OCkKcS4kMyhuLGwsMTgpCnEu
+JDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDQsMjI5KSkKcS4kMyhuLG0sNSkKcC4k
+MyhuLCJBWiIsMjI5KQpxLiQzKG4saywxMDIpCnEuJDMobiwiQCIsNjgpCnEuJDMobiwiWyIsMjMyKQpx
+LiQzKG4saiwxMzgpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDUsMjI5KSkK
+cS4kMyhuLG0sNSkKcC4kMyhuLCJBWiIsMjI5KQpxLiQzKG4saywxMDIpCnEuJDMobiwiQCIsNjgpCnEu
+JDMobixqLDEzOCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoNiwyMzEpKQpw
+LiQzKG4sIjE5Iiw3KQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4saiwxMzgpCnEuJDMobixpLDE3MikKcS4k
+MyhuLGgsMjA1KQpuPW8uYShyLiQyKDcsMjMxKSkKcC4kMyhuLCIwOSIsNykKcS4kMyhuLCJAIiw2OCkK
+cS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKcS4kMyhvLmEoci4kMig4LDgp
+KSwiXSIsNSkKbj1vLmEoci4kMig5LDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4sbCwxNikKcS4kMyhu
+LGosMjM0KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxNiwyMzUpKQpxLiQz
+KG4sbSwxMSkKcS4kMyhuLGwsMTcpCnEuJDMobixqLDIzNCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwy
+MDUpCm49by5hKHIuJDIoMTcsMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixqLDkpCnEuJDMobixpLDE3
+MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDEwLDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4sbCwx
+OCkKcS4kMyhuLGosMjM0KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxOCwy
+MzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTkpCnEuJDMobixqLDIzNCkKcS4kMyhuLGksMTcyKQpx
+LiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTksMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixqLDIzNCkK
+cS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTEsMjM1KSkKcS4kMyhuLG0sMTEp
+CnEuJDMobixqLDEwKQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxMiwyMzYp
+KQpxLiQzKG4sbSwxMikKcS4kMyhuLGksMTIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxMywyMzcp
+KQpxLiQzKG4sbSwxMykKcS4kMyhuLGksMTMpCnAuJDMoby5hKHIuJDIoMjAsMjQ1KSksImF6IiwyMSkK
+cj1vLmEoci4kMigyMSwyNDUpKQpwLiQzKHIsImF6IiwyMSkKcC4kMyhyLCIwOSIsMjEpCnEuJDMociwi
+Ky0uIiwyMSkKcmV0dXJuIGd9LApVQjpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8sbj0k
+LnZaKCkKZm9yKHM9Si5yWShhKSxyPWI7cjxjOysrcil7aWYoZDwwfHxkPj1uLmxlbmd0aClyZXR1cm4g
+SC5PSChuLGQpCnE9bltkXQpwPXMuVyhhLHIpXjk2Cm89cVtwPjk1PzMxOnBdCmQ9byYzMQpDLk5tLlk1
+KGUsbz4+PjUscil9cmV0dXJuIGR9LApSeDpmdW5jdGlvbihhKXtpZihhLmI9PT03JiZDLnhCLm5DKGEu
+YSwicGFja2FnZSIpJiZhLmM8PTApcmV0dXJuIFAuZkYoYS5hLGEuZSxhLmYpCnJldHVybi0xfSwKZkY6
+ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpmb3Iocz1iLHI9MDtzPGM7KytzKXtxPUMueEIuTyhhLHMp
+CmlmKHE9PT00NylyZXR1cm4gciE9PTA/czotMQppZihxPT09Mzd8fHE9PT01OClyZXR1cm4tMQpyfD1x
+XjQ2fXJldHVybi0xfSwKV0Y6ZnVuY3Rpb24gV0YoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCmlQOmZ1
+bmN0aW9uIGlQKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApYUzpmdW5jdGlvbiBYUygpe30sCkM2OmZ1
+bmN0aW9uIEM2KGEpe3RoaXMuYT1hfSwKRXo6ZnVuY3Rpb24gRXooKXt9LApMSzpmdW5jdGlvbiBMSygp
+e30sCmM6ZnVuY3Rpb24gYyhhLGIsYyxkKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1k
+fSwKYko6ZnVuY3Rpb24gYkooYSxiLGMsZCxlLGYpe3ZhciBfPXRoaXMKXy5lPWEKXy5mPWIKXy5hPWMK
+Xy5iPWQKXy5jPWUKXy5kPWZ9LAplWTpmdW5jdGlvbiBlWShhLGIsYyxkLGUpe3ZhciBfPXRoaXMKXy5m
+PWEKXy5hPWIKXy5iPWMKXy5jPWQKXy5kPWV9LAptcDpmdW5jdGlvbiBtcChhLGIsYyxkKXt2YXIgXz10
+aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kfSwKdWI6ZnVuY3Rpb24gdWIoYSl7dGhpcy5hPWF9LApk
+czpmdW5jdGlvbiBkcyhhKXt0aGlzLmE9YX0sCmxqOmZ1bmN0aW9uIGxqKGEpe3RoaXMuYT1hfSwKVVY6
+ZnVuY3Rpb24gVVYoYSl7dGhpcy5hPWF9LAprNTpmdW5jdGlvbiBrNSgpe30sCktZOmZ1bmN0aW9uIEtZ
+KCl7fSwKdDc6ZnVuY3Rpb24gdDcoYSl7dGhpcy5hPWF9LApDRDpmdW5jdGlvbiBDRChhKXt0aGlzLmE9
+YX0sCmFFOmZ1bmN0aW9uIGFFKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCmNYOmZ1
+bmN0aW9uIGNYKCl7fSwKQW46ZnVuY3Rpb24gQW4oKXt9LApOMzpmdW5jdGlvbiBOMyhhLGIsYyl7dGhp
+cy5hPWEKdGhpcy5iPWIKdGhpcy4kdGk9Y30sCmM4OmZ1bmN0aW9uIGM4KCl7fSwKTWg6ZnVuY3Rpb24g
+TWgoKXt9LApaZDpmdW5jdGlvbiBaZCgpe30sCk06ZnVuY3Rpb24gTShhKXt0aGlzLmE9YX0sCm4xOmZ1
+bmN0aW9uIG4xKGEpe3RoaXMuYT1hfSwKY1M6ZnVuY3Rpb24gY1MoYSl7dGhpcy5hPWF9LApWQzpmdW5j
+dGlvbiBWQyhhKXt0aGlzLmE9YX0sCkpUOmZ1bmN0aW9uIEpUKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9
+LApEbjpmdW5jdGlvbiBEbihhLGIsYyxkLGUsZixnKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1j
+Cl8uZD1kCl8uZT1lCl8uZj1mCl8ucj1nCl8uUT1fLno9Xy55PV8ueD0kfSwKUlo6ZnVuY3Rpb24gUloo
+KXt9LApNRTpmdW5jdGlvbiBNRShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKeTU6ZnVuY3Rpb24geTUo
+YSl7dGhpcy5hPWF9LApQRTpmdW5jdGlvbiBQRShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5j
+PWN9LAp5STpmdW5jdGlvbiB5SShhKXt0aGlzLmE9YX0sCmM2OmZ1bmN0aW9uIGM2KCl7fSwKcWQ6ZnVu
+Y3Rpb24gcWQoKXt9LApVZjpmdW5jdGlvbiBVZihhLGIsYyxkLGUsZixnLGgpe3ZhciBfPXRoaXMKXy5h
+PWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5mPWYKXy5yPWcKXy54PWgKXy55PW51bGx9LApxZTpm
+dW5jdGlvbiBxZShhLGIsYyxkLGUsZixnKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1k
+Cl8uZT1lCl8uZj1mCl8ucj1nCl8uUT1fLno9Xy55PV8ueD0kfSwKaUo6ZnVuY3Rpb24gaUooKXt9LApF
+MjpmdW5jdGlvbiBFMihhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKamc6ZnVuY3Rpb24gamcoYSxiKXt0
+aGlzLmE9YQp0aGlzLmI9Yn0sCkJmOmZ1bmN0aW9uIEJmKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApB
+czpmdW5jdGlvbiBBcygpe30sCkdFOmZ1bmN0aW9uIEdFKGEpe3RoaXMuYT1hfSwKTjc6ZnVuY3Rpb24g
+TjcoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCnVROmZ1bmN0aW9uIHVRKCl7fSwKaEY6ZnVuY3Rpb24g
+aEYoKXt9LApSNDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEKSC55OChiKQp0LmouYShkKQppZihI
+Lm9UKGIpKXtzPVtjXQpDLk5tLkZWKHMsZCkKZD1zfXI9dC56CnE9UC5DSChKLk0xKGQsUC53MCgpLHIp
+LCEwLHIpCnQuWS5hKGEpCnJldHVybiBQLndZKEguRWsoYSxxLG51bGwpKX0sCkRtOmZ1bmN0aW9uKGEs
+YixjKXt2YXIgcwp0cnl7aWYoT2JqZWN0LmlzRXh0ZW5zaWJsZShhKSYmIU9iamVjdC5wcm90b3R5cGUu
+aGFzT3duUHJvcGVydHkuY2FsbChhLGIpKXtPYmplY3QuZGVmaW5lUHJvcGVydHkoYSxiLHt2YWx1ZTpj
+fSkKcmV0dXJuITB9fWNhdGNoKHMpe0guUnUocyl9cmV0dXJuITF9LApPbTpmdW5jdGlvbihhLGIpe2lm
+KE9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbChhLGIpKXJldHVybiBhW2JdCnJldHVy
+biBudWxsfSwKd1k6ZnVuY3Rpb24oYSl7aWYoYT09bnVsbHx8dHlwZW9mIGE9PSJzdHJpbmcifHx0eXBl
+b2YgYT09Im51bWJlciJ8fEguclEoYSkpcmV0dXJuIGEKaWYoYSBpbnN0YW5jZW9mIFAuRTQpcmV0dXJu
+IGEuYQppZihILlI5KGEpKXJldHVybiBhCmlmKHQuYWsuYihhKSlyZXR1cm4gYQppZihhIGluc3RhbmNl
+b2YgUC5pUClyZXR1cm4gSC5vMihhKQppZih0LlkuYihhKSlyZXR1cm4gUC5oRShhLCIkZGFydF9qc0Z1
+bmN0aW9uIixuZXcgUC5QQygpKQpyZXR1cm4gUC5oRShhLCJfJGRhcnRfanNPYmplY3QiLG5ldyBQLm10
+KCQua0koKSkpfSwKaEU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPVAuT20oYSxiKQppZihzPT1udWxsKXtz
+PWMuJDEoYSkKUC5EbShhLGIscyl9cmV0dXJuIHN9LApkVTpmdW5jdGlvbihhKXt2YXIgcyxyCmlmKGE9
+PW51bGx8fHR5cGVvZiBhPT0ic3RyaW5nInx8dHlwZW9mIGE9PSJudW1iZXIifHx0eXBlb2YgYT09ImJv
+b2xlYW4iKXJldHVybiBhCmVsc2UgaWYoYSBpbnN0YW5jZW9mIE9iamVjdCYmSC5SOShhKSlyZXR1cm4g
+YQplbHNlIGlmKGEgaW5zdGFuY2VvZiBPYmplY3QmJnQuYWsuYihhKSlyZXR1cm4gYQplbHNlIGlmKGEg
+aW5zdGFuY2VvZiBEYXRlKXtzPUgudVAoYS5nZXRUaW1lKCkpCmlmKE1hdGguYWJzKHMpPD04NjRlMTMp
+cj0hMQplbHNlIHI9ITAKaWYocilILnYoUC54WSgiRGF0ZVRpbWUgaXMgb3V0c2lkZSB2YWxpZCByYW5n
+ZTogIitzKSkKSC5jYighMSwiaXNVdGMiLHQueSkKcmV0dXJuIG5ldyBQLmlQKHMsITEpfWVsc2UgaWYo
+YS5jb25zdHJ1Y3Rvcj09PSQua0koKSlyZXR1cm4gYS5vCmVsc2UgcmV0dXJuIFAuTkQoYSl9LApORDpm
+dW5jdGlvbihhKXtpZih0eXBlb2YgYT09ImZ1bmN0aW9uIilyZXR1cm4gUC5pUShhLCQueigpLG5ldyBQ
+LlFTKCkpCmlmKGEgaW5zdGFuY2VvZiBBcnJheSlyZXR1cm4gUC5pUShhLCQuUjgoKSxuZXcgUC5ucCgp
+KQpyZXR1cm4gUC5pUShhLCQuUjgoKSxuZXcgUC5VdCgpKX0sCmlROmZ1bmN0aW9uKGEsYixjKXt2YXIg
+cz1QLk9tKGEsYikKaWYocz09bnVsbHx8IShhIGluc3RhbmNlb2YgT2JqZWN0KSl7cz1jLiQxKGEpClAu
+RG0oYSxiLHMpfXJldHVybiBzfSwKUEM6ZnVuY3Rpb24gUEMoKXt9LAptdDpmdW5jdGlvbiBtdChhKXt0
+aGlzLmE9YX0sClFTOmZ1bmN0aW9uIFFTKCl7fSwKbnA6ZnVuY3Rpb24gbnAoKXt9LApVdDpmdW5jdGlv
+biBVdCgpe30sCkU0OmZ1bmN0aW9uIEU0KGEpe3RoaXMuYT1hfSwKcjc6ZnVuY3Rpb24gcjcoYSl7dGhp
+cy5hPWF9LApUejpmdW5jdGlvbiBUeihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LAp2ZzpmdW5jdGlv
+biB2Zygpe30sCm5kOmZ1bmN0aW9uIG5kKCl7fSwKS2U6ZnVuY3Rpb24gS2UoYSl7dGhpcy5hPWF9LApo
+aTpmdW5jdGlvbiBoaSgpe319LFI9ewpuejpmdW5jdGlvbihhKXt2YXIgcz1ILnVQKGEucSgwLCJub2Rl
+SWQiKSkKcmV0dXJuIG5ldyBSLkxMKEMuTm0uSHQoQy5yayxuZXcgUi5NRChhKSkscyl9LApPWDpmdW5j
+dGlvbihhKXtzd2l0Y2goYSl7Y2FzZSBDLkFkOnJldHVybiJBZGQgLyo/Ki8gaGludCIKY2FzZSBDLm5l
+OnJldHVybiJBZGQgLyohKi8gaGludCIKY2FzZSBDLndWOnJldHVybiJSZW1vdmUgLyo/Ki8gaGludCIK
+Y2FzZSBDLmZSOnJldHVybiJSZW1vdmUgLyohKi8gaGludCIKY2FzZSBDLm15OnJldHVybiJDaGFuZ2Ug
+dG8gLyo/Ki8gaGludCIKY2FzZSBDLnJ4OnJldHVybiJDaGFuZ2UgdG8gLyohKi8gaGludCJ9cmV0dXJu
+IG51bGx9LApMTDpmdW5jdGlvbiBMTChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKTUQ6ZnVuY3Rpb24g
+TUQoYSl7dGhpcy5hPWF9LApINzpmdW5jdGlvbiBINyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifX0sVD17
+bVE6ZnVuY3Rpb24gbVEoKXt9fSxVPXsKamY6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAKaWYoYT09bnVs
+bClzPW51bGwKZWxzZXtzPUguUUkoW10sdC5kNykKZm9yKHI9Si5JVCh0LlUuYShhKSk7ci5GKCk7KXtx
+PXIuZ2woKQpwPUouVTYocSkKcy5wdXNoKG5ldyBVLlNlKEguaChwLnEocSwiZGVzY3JpcHRpb24iKSks
+SC5oKHAucShxLCJocmVmIikpKSl9fXJldHVybiBzfSwKTmQ6ZnVuY3Rpb24oYSl7dmFyIHMscgppZihh
+PT1udWxsKXM9bnVsbAplbHNle3M9SC5RSShbXSx0LmFBKQpmb3Iocj1KLklUKHQuVS5hKGEpKTtyLkYo
+KTspcy5wdXNoKFUuTmYoci5nbCgpKSl9cmV0dXJuIHN9LApOZjpmdW5jdGlvbihhKXt2YXIgcz1KLlU2
+KGEpLHI9SC5oKHMucShhLCJkZXNjcmlwdGlvbiIpKSxxPUguUUkoW10sdC5hSikKZm9yKHM9Si5JVCh0
+LlUuYShzLnEoYSwiZW50cmllcyIpKSk7cy5GKCk7KXEucHVzaChVLlJqKHMuZ2woKSkpCnJldHVybiBu
+ZXcgVS55RChyLHEpfSwKUmo6ZnVuY3Rpb24oYSl7dmFyIHMscj1KLlU2KGEpLHE9SC5oKHIucShhLCJk
+ZXNjcmlwdGlvbiIpKSxwPUguaChyLnEoYSwiZnVuY3Rpb24iKSksbz1yLnEoYSwibGluayIpCmlmKG89
+PW51bGwpbz1udWxsCmVsc2V7cz1KLlU2KG8pCm89bmV3IFUuTWwoSC5oKHMucShvLCJocmVmIikpLEgu
+dVAocy5xKG8sImxpbmUiKSksSC5oKHMucShvLCJwYXRoIikpKX1yPXQuZksuYShyLnEoYSwiaGludEFj
+dGlvbnMiKSkKcj1yPT1udWxsP251bGw6Si5NMShyLG5ldyBVLmFOKCksdC5hWCkKcj1yPT1udWxsP251
+bGw6ci5icigwKQpyZXR1cm4gbmV3IFUud2IocSxwLG8scj09bnVsbD9DLmRuOnIpfSwKZDI6ZnVuY3Rp
+b24gZDIoYSxiLGMsZCxlLGYpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUK
+Xy5mPWZ9LApTZTpmdW5jdGlvbiBTZShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKTWw6ZnVuY3Rpb24g
+TWwoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKeUQ6ZnVuY3Rpb24geUQoYSxiKXt0
+aGlzLmE9YQp0aGlzLmI9Yn0sCndiOmZ1bmN0aW9uIHdiKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEK
+Xy5iPWIKXy5jPWMKXy5kPWR9LAphTjpmdW5jdGlvbiBhTigpe30sCmIwOmZ1bmN0aW9uIGIwKCl7fX0s
+Vz17CngzOmZ1bmN0aW9uKCl7cmV0dXJuIHdpbmRvd30sClpyOmZ1bmN0aW9uKCl7cmV0dXJuIGRvY3Vt
+ZW50fSwKSjY6ZnVuY3Rpb24oYSl7dmFyIHM9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiYSIpCmlmKGEh
+PW51bGwpQy54bi5zTFUocyxhKQpyZXR1cm4gc30sCkxqOmZ1bmN0aW9uKGEpe3JldHVybiBDU1MuZXNj
+YXBlKGEpfSwKVTk6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9ZG9jdW1lbnQuYm9keQpyLnRvU3RyaW5n
+CnM9Qy5SWS5yNihyLGEsYixjKQpzLnRvU3RyaW5nCnI9dC5hYwpyPW5ldyBILlU1KG5ldyBXLmU3KHMp
+LHIuQygiYTIobEQuRSkiKS5hKG5ldyBXLkN2KCkpLHIuQygiVTU8bEQuRT4iKSkKcmV0dXJuIHQuaC5h
+KHIuZ3I4KHIpKX0sCnJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT0iZWxlbWVudCB0YWcgdW5hdmFpbGFi
+bGUiCnRyeXtzPUouWUUoYSkKaWYodHlwZW9mIHMuZ25zKGEpPT0ic3RyaW5nIilxPXMuZ25zKGEpfWNh
+dGNoKHIpe0guUnUocil9cmV0dXJuIHF9LApDMDpmdW5jdGlvbihhLGIpe2E9YStiJjUzNjg3MDkxMQph
+PWErKChhJjUyNDI4Nyk8PDEwKSY1MzY4NzA5MTEKcmV0dXJuIGFeYT4+PjZ9LApyRTpmdW5jdGlvbihh
+LGIsYyxkKXt2YXIgcz1XLkMwKFcuQzAoVy5DMChXLkMwKDAsYSksYiksYyksZCkscj1zKygocyY2NzEw
+ODg2Myk8PDMpJjUzNjg3MDkxMQpyXj1yPj4+MTEKcmV0dXJuIHIrKChyJjE2MzgzKTw8MTUpJjUzNjg3
+MDkxMX0sClROOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWEuY2xhc3NMaXN0CmZvcihzPWIubGVuZ3Ro
+LHI9MDtyPGIubGVuZ3RoO2IubGVuZ3RoPT09c3x8KDAsSC5saykoYiksKytyKXEuYWRkKGJbcl0pfSwK
+SkU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz1XLmFGKG5ldyBXLnZOKGMpLHQuQikKaWYocyE9bnVs
+bCYmITApSi5kWihhLGIscywhMSkKcmV0dXJuIG5ldyBXLnhDKGEsYixzLCExLGUuQygieEM8MD4iKSl9
+LApUdzpmdW5jdGlvbihhKXt2YXIgcz1XLko2KG51bGwpLHI9d2luZG93LmxvY2F0aW9uCnM9bmV3IFcu
+SlEobmV3IFcubWsocyxyKSkKcy5DWShhKQpyZXR1cm4gc30sCnFEOmZ1bmN0aW9uKGEsYixjLGQpe3Qu
+aC5hKGEpCkguaChiKQpILmgoYykKdC5jci5hKGQpCnJldHVybiEwfSwKblo6ZnVuY3Rpb24oYSxiLGMs
+ZCl7dmFyIHMscixxCnQuaC5hKGEpCkguaChiKQpILmgoYykKcz10LmNyLmEoZCkuYQpyPXMuYQpDLnhu
+LnNMVShyLGMpCnE9ci5ob3N0bmFtZQpzPXMuYgppZighKHE9PXMuaG9zdG5hbWUmJnIucG9ydD09cy5w
+b3J0JiZyLnByb3RvY29sPT1zLnByb3RvY29sKSlpZihxPT09IiIpaWYoci5wb3J0PT09IiIpe3M9ci5w
+cm90b2NvbApzPXM9PT0iOiJ8fHM9PT0iIn1lbHNlIHM9ITEKZWxzZSBzPSExCmVsc2Ugcz0hMApyZXR1
+cm4gc30sCkJsOmZ1bmN0aW9uKCl7dmFyIHM9dC5OLHI9UC50TShDLlF4LHMpLHE9dC5kMC5hKG5ldyBX
+LklBKCkpLHA9SC5RSShbIlRFTVBMQVRFIl0sdC5zKQpzPW5ldyBXLmN0KHIsUC5McyhzKSxQLkxzKHMp
+LFAuTHMocyksbnVsbCkKcy5DWShudWxsLG5ldyBILmxKKEMuUXgscSx0LmZqKSxwLG51bGwpCnJldHVy
+biBzfSwKcWM6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoYT09bnVsbClyZXR1cm4gbnVsbAppZigicG9zdE1l
+c3NhZ2UiIGluIGEpe3M9Vy5QMShhKQppZih0LmFTLmIocykpcmV0dXJuIHMKcmV0dXJuIG51bGx9ZWxz
+ZSByZXR1cm4gdC5jaC5hKGEpfSwKUDE6ZnVuY3Rpb24oYSl7aWYoYT09PXdpbmRvdylyZXR1cm4gdC5j
+aS5hKGEpCmVsc2UgcmV0dXJuIG5ldyBXLmRXKCl9LAphRjpmdW5jdGlvbihhLGIpe3ZhciBzPSQuWDMK
+aWYocz09PUMuTlUpcmV0dXJuIGEKcmV0dXJuIHMuUHkoYSxiKX0sCnFFOmZ1bmN0aW9uIHFFKCl7fSwK
+R2g6ZnVuY3Rpb24gR2goKXt9LApmWTpmdW5jdGlvbiBmWSgpe30sCnJaOmZ1bmN0aW9uIHJaKCl7fSwK
+QXo6ZnVuY3Rpb24gQXooKXt9LApRUDpmdW5jdGlvbiBRUCgpe30sCm54OmZ1bmN0aW9uIG54KCl7fSwK
+b0o6ZnVuY3Rpb24gb0ooKXt9LAppZDpmdW5jdGlvbiBpZCgpe30sClFGOmZ1bmN0aW9uIFFGKCl7fSwK
+Tmg6ZnVuY3Rpb24gTmgoKXt9LAphZTpmdW5jdGlvbiBhZSgpe30sCklCOmZ1bmN0aW9uIElCKCl7fSwK
+TlE6ZnVuY3Rpb24gTlEoKXt9LAp3ejpmdW5jdGlvbiB3eihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9
+LApjdjpmdW5jdGlvbiBjdigpe30sCkN2OmZ1bmN0aW9uIEN2KCl7fSwKZWE6ZnVuY3Rpb24gZWEoKXt9
+LApEMDpmdW5jdGlvbiBEMCgpe30sCmhIOmZ1bmN0aW9uIGhIKCl7fSwKaDQ6ZnVuY3Rpb24gaDQoKXt9
+LApicjpmdW5jdGlvbiBicigpe30sClZiOmZ1bmN0aW9uIFZiKCl7fSwKZko6ZnVuY3Rpb24gZkooKXt9
+LAp3YTpmdW5jdGlvbiB3YSgpe30sClNnOmZ1bmN0aW9uIFNnKCl7fSwKdzc6ZnVuY3Rpb24gdzcoKXt9
+LApBajpmdW5jdGlvbiBBaigpe30sCmU3OmZ1bmN0aW9uIGU3KGEpe3RoaXMuYT1hfSwKdUg6ZnVuY3Rp
+b24gdUgoKXt9LApCSDpmdW5jdGlvbiBCSCgpe30sClNOOmZ1bmN0aW9uIFNOKCl7fSwKZXc6ZnVuY3Rp
+b24gZXcoKXt9LApscDpmdW5jdGlvbiBscCgpe30sClRiOmZ1bmN0aW9uIFRiKCl7fSwKSXY6ZnVuY3Rp
+b24gSXYoKXt9LApXUDpmdW5jdGlvbiBXUCgpe30sCnlZOmZ1bmN0aW9uIHlZKCl7fSwKdzY6ZnVuY3Rp
+b24gdzYoKXt9LApLNTpmdW5jdGlvbiBLNSgpe30sCkNtOmZ1bmN0aW9uIENtKCl7fSwKQ1E6ZnVuY3Rp
+b24gQ1EoKXt9LAp3NDpmdW5jdGlvbiB3NCgpe30sCnJoOmZ1bmN0aW9uIHJoKCl7fSwKY2Y6ZnVuY3Rp
+b24gY2YoKXt9LAppNzpmdW5jdGlvbiBpNyhhKXt0aGlzLmE9YX0sClN5OmZ1bmN0aW9uIFN5KGEpe3Ro
+aXMuYT1hfSwKS1M6ZnVuY3Rpb24gS1MoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkEzOmZ1bmN0aW9u
+IEEzKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApJNDpmdW5jdGlvbiBJNChhKXt0aGlzLmE9YX0sCkZr
+OmZ1bmN0aW9uIEZrKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sClJPOmZ1bmN0aW9uIFJPKGEsYixj
+LGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4kdGk9ZH0sCmV1OmZ1bmN0aW9uIGV1KGEs
+YixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4kdGk9ZH0sCnhDOmZ1bmN0aW9uIHhD
+KGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmI9YQpfLmM9YgpfLmQ9YwpfLmU9ZApfLiR0aT1lfSwKdk46
+ZnVuY3Rpb24gdk4oYSl7dGhpcy5hPWF9LApKUTpmdW5jdGlvbiBKUShhKXt0aGlzLmE9YX0sCkdtOmZ1
+bmN0aW9uIEdtKCl7fSwKdkQ6ZnVuY3Rpb24gdkQoYSl7dGhpcy5hPWF9LApVdjpmdW5jdGlvbiBVdihh
+KXt0aGlzLmE9YX0sCkVnOmZ1bmN0aW9uIEVnKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9
+Y30sCm02OmZ1bmN0aW9uIG02KCl7fSwKRW86ZnVuY3Rpb24gRW8oKXt9LApXazpmdW5jdGlvbiBXaygp
+e30sCmN0OmZ1bmN0aW9uIGN0KGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmU9YQpfLmE9YgpfLmI9Ywpf
+LmM9ZApfLmQ9ZX0sCklBOmZ1bmN0aW9uIElBKCl7fSwKT3c6ZnVuY3Rpb24gT3coKXt9LApXOTpmdW5j
+dGlvbiBXOShhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9LTEKXy5kPW51bGwKXy4kdGk9
+Y30sCmRXOmZ1bmN0aW9uIGRXKCl7fSwKbWs6ZnVuY3Rpb24gbWsoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
+Yn0sCktvOmZ1bmN0aW9uIEtvKGEpe3RoaXMuYT1hCnRoaXMuYj0wfSwKZm06ZnVuY3Rpb24gZm0oYSl7
+dGhpcy5hPWF9LApMZTpmdW5jdGlvbiBMZSgpe30sCks3OmZ1bmN0aW9uIEs3KCl7fSwKckI6ZnVuY3Rp
+b24gckIoKXt9LApYVzpmdW5jdGlvbiBYVygpe30sCm9hOmZ1bmN0aW9uIG9hKCl7fX0sWD17CkNMOmZ1
+bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuPWIueFooYSkKYi5oSyhhKQppZihuIT1udWxsKWE9Si5L
+VihhLG4ubGVuZ3RoKQpzPXQucwpyPUguUUkoW10scykKcT1ILlFJKFtdLHMpCnM9YS5sZW5ndGgKaWYo
+cyE9PTAmJmIucjQoQy54Qi5XKGEsMCkpKXtpZigwPj1zKXJldHVybiBILk9IKGEsMCkKQy5ObS5pKHEs
+YVswXSkKcD0xfWVsc2V7Qy5ObS5pKHEsIiIpCnA9MH1mb3Iobz1wO288czsrK28paWYoYi5yNChDLnhC
+LlcoYSxvKSkpe0MuTm0uaShyLEMueEIuTmooYSxwLG8pKQpDLk5tLmkocSxhW29dKQpwPW8rMX1pZihw
+PHMpe0MuTm0uaShyLEMueEIueW4oYSxwKSkKQy5ObS5pKHEsIiIpfXJldHVybiBuZXcgWC5XRChiLG4s
+cixxKX0sCldEOmZ1bmN0aW9uIFdEKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5kPWMK
+Xy5lPWR9LApJNzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFguZHYoYSl9LApkdjpmdW5jdGlvbiBkdihh
+KXt0aGlzLmE9YX19CnZhciB3PVtCLEMsRCxFLEYsSCxKLEwsTSxPLFAsUixULFUsVyxYXQpodW5rSGVs
+cGVycy5zZXRGdW5jdGlvbk5hbWVzSWZOZWNlc3NhcnkodykKdmFyICQ9e30KSC5GSy5wcm90b3R5cGU9
+e30KSi5Hdi5wcm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe3JldHVybiBhPT09Yn0sCmdpTzpmdW5j
+dGlvbihhKXtyZXR1cm4gSC5lUShhKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICci
+K0guRWooSC5saChhKSkrIicifSwKZTc6ZnVuY3Rpb24oYSxiKXt0Lm8uYShiKQp0aHJvdyBILmIoUC5s
+cihhLGIuZ1dhKCksYi5nbmQoKSxiLmdWbSgpKSl9fQpKLnlFLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
+YSl7cmV0dXJuIFN0cmluZyhhKX0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gYT81MTkwMTg6MjE4MTU5
+fSwKJGlhMjoxfQpKLndlLnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51bGw9PWJ9
+LAp3OmZ1bmN0aW9uKGEpe3JldHVybiJudWxsIn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gMH0sCmU3
+OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuU2ooYSx0Lm8uYShiKSl9LAokaWM4OjF9CkouTUYucHJv
+dG90eXBlPXsKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiAwfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3Ry
+aW5nKGEpfSwKJGl2bToxfQpKLmlDLnByb3RvdHlwZT17fQpKLmtkLnByb3RvdHlwZT17fQpKLmM1LnBy
+b3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9YVskLnooKV0KaWYocz09bnVsbClyZXR1cm4gdGhp
+cy50KGEpCnJldHVybiJKYXZhU2NyaXB0IGZ1bmN0aW9uIGZvciAiK0guRWooSi53KHMpKX0sCiRpRUg6
+MX0KSi5qZC5wcm90b3R5cGU9ewpkcjpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgSC5qVihhLEgudDYo
+YSkuQygiQDwxPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9LAppOmZ1bmN0aW9uKGEsYil7SC50NihhKS5j
+LmEoYikKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiYWRkIikpCmEucHVzaChiKX0sClc0OmZ1
+bmN0aW9uKGEsYil7dmFyIHMKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgicmVtb3ZlQXQiKSkK
+cz1hLmxlbmd0aAppZihiPj1zKXRocm93IEguYihQLk83KGIsbnVsbCkpCnJldHVybiBhLnNwbGljZShi
+LDEpWzBdfSwKVUc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKSC50NihhKS5DKCJjWDwxPiIpLmEoYykK
+aWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiaW5zZXJ0QWxsIikpClAud0EoYiwwLGEubGVuZ3Ro
+LCJpbmRleCIpCmlmKCF0LmQuYihjKSljPUouUlgoYykKcz1KLkhtKGMpCmEubGVuZ3RoPWEubGVuZ3Ro
+K3MKcj1iK3MKdGhpcy5ZVyhhLHIsYS5sZW5ndGgsYSxiKQp0aGlzLnZnKGEsYixyLGMpfSwKRlY6ZnVu
+Y3Rpb24oYSxiKXt2YXIgcwpILnQ2KGEpLkMoImNYPDE+IikuYShiKQppZighIWEuZml4ZWQkbGVuZ3Ro
+KUgudihQLkw0KCJhZGRBbGwiKSkKaWYoQXJyYXkuaXNBcnJheShiKSl7dGhpcy5LaChhLGIpCnJldHVy
+bn1mb3Iocz1KLklUKGIpO3MuRigpOylhLnB1c2gocy5nbCgpKX0sCktoOmZ1bmN0aW9uKGEsYil7dmFy
+IHMscgp0LmIuYShiKQpzPWIubGVuZ3RoCmlmKHM9PT0wKXJldHVybgppZihhPT09Yil0aHJvdyBILmIo
+UC5hNChhKSkKZm9yKHI9MDtyPHM7KytyKWEucHVzaChiW3JdKX0sCkUyOmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcz1ILnQ2KGEpCnJldHVybiBuZXcgSC5sSihhLHMuS3EoYykuQygiMSgyKSIpLmEoYikscy5DKCJA
+PDE+IikuS3EoYykuQygibEo8MSwyPiIpKX0sCms6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPVAuTzgoYS5s
+ZW5ndGgsIiIsITEsdC5OKQpmb3Iocz0wO3M8YS5sZW5ndGg7KytzKXRoaXMuWTUocixzLEguRWooYVtz
+XSkpCnJldHVybiByLmpvaW4oYil9LAplUjpmdW5jdGlvbihhLGIpe3JldHVybiBILnFDKGEsYixudWxs
+LEgudDYoYSkuYyl9LApOMDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEKZC5hKGIpCkgudDYoYSku
+S3EoZCkuQygiMSgxLDIpIikuYShjKQpzPWEubGVuZ3RoCmZvcihyPWIscT0wO3E8czsrK3Epe3I9Yy4k
+MihyLGFbcV0pCmlmKGEubGVuZ3RoIT09cyl0aHJvdyBILmIoUC5hNChhKSl9cmV0dXJuIHJ9LApIdDpm
+dW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8KSC50NihhKS5DKCJhMigxKSIpLmEoYikKcz1hLmxlbmd0
+aApmb3Iocj1udWxsLHE9ITEscD0wO3A8czsrK3Ape289YVtwXQppZihILm9UKGIuJDEobykpKXtpZihx
+KXRocm93IEguYihILkFtKCkpCnI9bwpxPSEwfWlmKHMhPT1hLmxlbmd0aCl0aHJvdyBILmIoUC5hNChh
+KSl9aWYocSlyZXR1cm4gcgp0aHJvdyBILmIoSC5XcCgpKX0sCkU6ZnVuY3Rpb24oYSxiKXtpZihiPDB8
+fGI+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsYikKcmV0dXJuIGFbYl19LApndEg6ZnVuY3Rpb24oYSl7
+aWYoYS5sZW5ndGg+MClyZXR1cm4gYVswXQp0aHJvdyBILmIoSC5XcCgpKX0sCmdyWjpmdW5jdGlvbihh
+KXt2YXIgcz1hLmxlbmd0aAppZihzPjApcmV0dXJuIGFbcy0xXQp0aHJvdyBILmIoSC5XcCgpKX0sCllX
+OmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHMscixxLHAsbwpILnQ2KGEpLkMoImNYPDE+IikuYShkKQpp
+ZighIWEuaW1tdXRhYmxlJGxpc3QpSC52KFAuTDQoInNldFJhbmdlIikpClAuakIoYixjLGEubGVuZ3Ro
+KQpzPWMtYgppZihzPT09MClyZXR1cm4KUC5rMShlLCJza2lwQ291bnQiKQppZih0LmouYihkKSl7cj1k
+CnE9ZX1lbHNle3I9Si5BNShkLGUpLnR0KDAsITEpCnE9MH1wPUouVTYocikKaWYocStzPnAuZ0Eocikp
+dGhyb3cgSC5iKEguYXIoKSkKaWYocTxiKWZvcihvPXMtMTtvPj0wOy0tbylhW2Irb109cC5xKHIscStv
+KQplbHNlIGZvcihvPTA7bzxzOysrbylhW2Irb109cC5xKHIscStvKX0sCnZnOmZ1bmN0aW9uKGEsYixj
+LGQpe3JldHVybiB0aGlzLllXKGEsYixjLGQsMCl9LApWcjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC50
+NihhKS5DKCJhMigxKSIpLmEoYikKcz1hLmxlbmd0aApmb3Iocj0wO3I8czsrK3Ipe2lmKEgub1QoYi4k
+MShhW3JdKSkpcmV0dXJuITAKaWYoYS5sZW5ndGghPT1zKXRocm93IEguYihQLmE0KGEpKX1yZXR1cm4h
+MX0sCnRnOmZ1bmN0aW9uKGEsYil7dmFyIHMKZm9yKHM9MDtzPGEubGVuZ3RoOysrcylpZihKLlJNKGFb
+c10sYikpcmV0dXJuITAKcmV0dXJuITF9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RoPT09
+MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGghPT0wfSwKdzpmdW5jdGlvbihhKXtyZXR1
+cm4gUC54KGEsIlsiLCJdIil9LAp0dDpmdW5jdGlvbihhLGIpe3ZhciBzPUguUUkoYS5zbGljZSgwKSxI
+LnQ2KGEpKQpyZXR1cm4gc30sCmJyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnR0KGEsITApfSwKZ206
+ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBKLm0xKGEsYS5sZW5ndGgsSC50NihhKS5DKCJtMTwxPiIpKX0s
+CmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gSC5lUShhKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxl
+bmd0aH0sCnNBOmZ1bmN0aW9uKGEsYil7aWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgic2V0IGxl
+bmd0aCIpKQppZihiPDApdGhyb3cgSC5iKFAuVEUoYiwwLG51bGwsIm5ld0xlbmd0aCIsbnVsbCkpCmEu
+bGVuZ3RoPWJ9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93
+IEguYihILnUoYSxiKSkKcmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIsYyl7SC50NihhKS5jLmEo
+YykKaWYoISFhLmltbXV0YWJsZSRsaXN0KUgudihQLkw0KCJpbmRleGVkIHNldCIpKQppZihiPj1hLmxl
+bmd0aHx8YjwwKXRocm93IEguYihILnUoYSxiKSkKYVtiXT1jfSwKJGliUToxLAokaWNYOjEsCiRpek06
+MX0KSi5Qby5wcm90b3R5cGU9e30KSi5tMS5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVybiB0
+aGlzLmR9LApGOmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5hLHA9cS5sZW5ndGgKaWYoci5iIT09
+cCl0aHJvdyBILmIoSC5sayhxKSkKcz1yLmMKaWYocz49cCl7ci5zTShudWxsKQpyZXR1cm4hMX1yLnNN
+KHFbc10pOysrci5jCnJldHVybiEwfSwKc006ZnVuY3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/
+IikuYShhKX0sCiRpQW46MX0KSi5xSS5wcm90b3R5cGU9ewp6UTpmdW5jdGlvbihhKXtpZihhPjApe2lm
+KGEhPT0xLzApcmV0dXJuIE1hdGgucm91bmQoYSl9ZWxzZSBpZihhPi0xLzApcmV0dXJuIDAtTWF0aC5y
+b3VuZCgwLWEpCnRocm93IEguYihQLkw0KCIiK2ErIi5yb3VuZCgpIikpfSwKdzpmdW5jdGlvbihhKXtp
+ZihhPT09MCYmMS9hPDApcmV0dXJuIi0wLjAiCmVsc2UgcmV0dXJuIiIrYX0sCmdpTzpmdW5jdGlvbihh
+KXt2YXIgcyxyLHEscCxvPWF8MAppZihhPT09bylyZXR1cm4gbyY1MzY4NzA5MTEKcz1NYXRoLmFicyhh
+KQpyPU1hdGgubG9nKHMpLzAuNjkzMTQ3MTgwNTU5OTQ1M3wwCnE9TWF0aC5wb3coMixyKQpwPXM8MT9z
+L3E6cS9zCnJldHVybigocCo5MDA3MTk5MjU0NzQwOTkyfDApKyhwKjM1NDIyNDMxODExNzY1MjF8MCkp
+KjU5OTE5NytyKjEyNTkmNTM2ODcwOTExfSwKelk6ZnVuY3Rpb24oYSxiKXt2YXIgcz1hJWIKaWYocz09
+PTApcmV0dXJuIDAKaWYocz4wKXJldHVybiBzCnJldHVybiBzK2J9LApCVTpmdW5jdGlvbihhLGIpe3Jl
+dHVybihhfDApPT09YT9hL2J8MDp0aGlzLkRKKGEsYil9LApESjpmdW5jdGlvbihhLGIpe3ZhciBzPWEv
+YgppZihzPj0tMjE0NzQ4MzY0OCYmczw9MjE0NzQ4MzY0NylyZXR1cm4gc3wwCmlmKHM+MCl7aWYocyE9
+PTEvMClyZXR1cm4gTWF0aC5mbG9vcihzKX1lbHNlIGlmKHM+LTEvMClyZXR1cm4gTWF0aC5jZWlsKHMp
+CnRocm93IEguYihQLkw0KCJSZXN1bHQgb2YgdHJ1bmNhdGluZyBkaXZpc2lvbiBpcyAiK0guRWoocykr
+IjogIitILkVqKGEpKyIgfi8gIitiKSl9LAp3RzpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKGE+MClzPXRo
+aXMucDMoYSxiKQplbHNle3M9Yj4zMT8zMTpiCnM9YT4+cz4+PjB9cmV0dXJuIHN9LApiZjpmdW5jdGlv
+bihhLGIpe2lmKDA+Yil0aHJvdyBILmIoSC50TChiKSkKcmV0dXJuIHRoaXMucDMoYSxiKX0sCnAzOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIGI+MzE/MDphPj4+Yn0sCiRpQ1A6MSwKJGlaWjoxfQpKLmJVLnByb3Rv
+dHlwZT17JGlJajoxfQpKLmtELnByb3RvdHlwZT17fQpKLkRyLnByb3RvdHlwZT17Ck86ZnVuY3Rpb24o
+YSxiKXtpZihiPDApdGhyb3cgSC5iKEgudShhLGIpKQppZihiPj1hLmxlbmd0aClILnYoSC51KGEsYikp
+CnJldHVybiBhLmNoYXJDb2RlQXQoYil9LApXOmZ1bmN0aW9uKGEsYil7aWYoYj49YS5sZW5ndGgpdGhy
+b3cgSC5iKEgudShhLGIpKQpyZXR1cm4gYS5jaGFyQ29kZUF0KGIpfSwKZGQ6ZnVuY3Rpb24oYSxiKXty
+ZXR1cm4gbmV3IEgudW4oYixhLDApfSwKaDpmdW5jdGlvbihhLGIpe2lmKHR5cGVvZiBiIT0ic3RyaW5n
+Iil0aHJvdyBILmIoUC5MMyhiLG51bGwsbnVsbCkpCnJldHVybiBhK2J9LApUYzpmdW5jdGlvbihhLGIp
+e3ZhciBzPWIubGVuZ3RoLHI9YS5sZW5ndGgKaWYocz5yKXJldHVybiExCnJldHVybiBiPT09dGhpcy55
+bihhLHItcyl9LAppNzpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1QLmpCKGIsYyxhLmxlbmd0aCkscj1h
+LnN1YnN0cmluZygwLGIpLHE9YS5zdWJzdHJpbmcocykKcmV0dXJuIHIrZCtxfSwKUWk6ZnVuY3Rpb24o
+YSxiLGMpe3ZhciBzCmlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAsYS5sZW5ndGgs
+bnVsbCxudWxsKSkKcz1jK2IubGVuZ3RoCmlmKHM+YS5sZW5ndGgpcmV0dXJuITEKcmV0dXJuIGI9PT1h
+LnN1YnN0cmluZyhjLHMpfSwKbkM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5RaShhLGIsMCl9LApO
+ajpmdW5jdGlvbihhLGIsYyl7aWYoYz09bnVsbCljPWEubGVuZ3RoCmlmKGI8MCl0aHJvdyBILmIoUC5P
+NyhiLG51bGwpKQppZihiPmMpdGhyb3cgSC5iKFAuTzcoYixudWxsKSkKaWYoYz5hLmxlbmd0aCl0aHJv
+dyBILmIoUC5PNyhjLG51bGwpKQpyZXR1cm4gYS5zdWJzdHJpbmcoYixjKX0sCnluOmZ1bmN0aW9uKGEs
+Yil7cmV0dXJuIHRoaXMuTmooYSxiLG51bGwpfSwKaGM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEudG9Mb3dl
+ckNhc2UoKX0sCmJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEudHJpbSgpLG89cC5sZW5ndGgKaWYo
+bz09PTApcmV0dXJuIHAKaWYodGhpcy5XKHAsMCk9PT0xMzMpe3M9Si5tbShwLDEpCmlmKHM9PT1vKXJl
+dHVybiIifWVsc2Ugcz0wCnI9by0xCnE9dGhpcy5PKHAscik9PT0xMzM/Si5jMShwLHIpOm8KaWYocz09
+PTAmJnE9PT1vKXJldHVybiBwCnJldHVybiBwLnN1YnN0cmluZyhzLHEpfSwKVDpmdW5jdGlvbihhLGIp
+e3ZhciBzLHIKaWYoMD49YilyZXR1cm4iIgppZihiPT09MXx8YS5sZW5ndGg9PT0wKXJldHVybiBhCmlm
+KGIhPT1iPj4+MCl0aHJvdyBILmIoQy5FcSkKZm9yKHM9YSxyPSIiOyEwOyl7aWYoKGImMSk9PT0xKXI9
+cytyCmI9Yj4+PjEKaWYoYj09PTApYnJlYWsKcys9c31yZXR1cm4gcn0sClhVOmZ1bmN0aW9uKGEsYixj
+KXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5iKFAuVEUoYywwLGEubGVuZ3RoLG51bGws
+bnVsbCkpCnM9YS5pbmRleE9mKGIsYykKcmV0dXJuIHN9LApPWTpmdW5jdGlvbihhLGIpe3JldHVybiB0
+aGlzLlhVKGEsYiwwKX0sClBrOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCmlmKGM9PW51bGwpYz1hLmxl
+bmd0aAplbHNlIGlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAsYS5sZW5ndGgsbnVs
+bCxudWxsKSkKcz1iLmxlbmd0aApyPWEubGVuZ3RoCmlmKGMrcz5yKWM9ci1zCnJldHVybiBhLmxhc3RJ
+bmRleE9mKGIsYyl9LApjbjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlBrKGEsYixudWxsKX0sCklz
+OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1hLmxlbmd0aAppZihjPnMpdGhyb3cgSC5iKFAuVEUoYywwLHMs
+bnVsbCxudWxsKSkKcmV0dXJuIEguU1EoYSxiLGMpfSwKdGc6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhp
+cy5JcyhhLGIsMCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBhfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBz
+LHIscQpmb3Iocz1hLmxlbmd0aCxyPTAscT0wO3E8czsrK3Epe3I9cithLmNoYXJDb2RlQXQocSkmNTM2
+ODcwOTExCnI9cisoKHImNTI0Mjg3KTw8MTApJjUzNjg3MDkxMQpyXj1yPj42fXI9cisoKHImNjcxMDg4
+NjMpPDwzKSY1MzY4NzA5MTEKcl49cj4+MTEKcmV0dXJuIHIrKChyJjE2MzgzKTw8MTUpJjUzNjg3MDkx
+MX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIp
+CmlmKGI+PWEubGVuZ3RofHwhMSl0aHJvdyBILmIoSC51KGEsYikpCnJldHVybiBhW2JdfSwKJGl2WDox
+LAokaXFVOjF9CkguQlIucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9SC5MaCh0aGlzKQpy
+ZXR1cm4gbmV3IEguRTcoSi5JVCh0aGlzLmdPTigpKSxzLkMoIkA8MT4iKS5LcShzLlFbMV0pLkMoIkU3
+PDEsMj4iKSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gSi5IbSh0aGlzLmdPTigpKX0sCmdsMDpmdW5j
+dGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmdPTigpKX0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gSi5G
+Nyh0aGlzLmdPTigpKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5MaCh0aGlzKQpyZXR1cm4gSC5H
+SihKLkE1KHRoaXMuZ09OKCksYikscy5jLHMuUVsxXSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEgu
+TGgodGhpcykuUVsxXS5hKEouR0EodGhpcy5nT04oKSxiKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBK
+LncodGhpcy5nT04oKSl9fQpILkU3LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5h
+LkYoKX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuJHRpLlFbMV0uYSh0aGlzLmEuZ2woKSl9LAok
+aUFuOjF9CkguWnkucHJvdG90eXBlPXsKZ09OOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX19Ckgub2wu
+cHJvdG90eXBlPXskaWJROjF9CkguVXEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0
+aGlzLiR0aS5RWzFdLmEoSi54OSh0aGlzLmEsSC51UChiKSkpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3Zh
+ciBzPXRoaXMuJHRpCkoudTkodGhpcy5hLGIscy5jLmEocy5RWzFdLmEoYykpKX0sCiRpYlE6MSwKJGl6
+TToxfQpILmpWLnByb3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILmpWKHRoaXMu
+YSx0aGlzLiR0aS5DKCJAPDE+IikuS3EoYikuQygialY8MSwyPiIpKX0sCmdPTjpmdW5jdGlvbigpe3Jl
+dHVybiB0aGlzLmF9fQpILm4ucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz0iTGF0ZUluaXRp
+YWxpemF0aW9uRXJyb3I6ICIrdGhpcy5hCnJldHVybiBzfX0KSC5yMy5wcm90b3R5cGU9ewp3OmZ1bmN0
+aW9uKGEpe3ZhciBzPSJSZWFjaGFiaWxpdHlFcnJvcjogIit0aGlzLmEKcmV0dXJuIHN9fQpILnFqLnBy
+b3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEubGVuZ3RofSwKcTpmdW5jdGlvbihh
+LGIpe3JldHVybiBDLnhCLk8odGhpcy5hLEgudVAoYikpfX0KSC5HTS5wcm90b3R5cGU9ewp3OmZ1bmN0
+aW9uKGEpe3JldHVybiJOdWxsIGlzIG5vdCBhIHZhbGlkIHZhbHVlIGZvciB0aGUgcGFyYW1ldGVyICci
+K3RoaXMuYSsiJyBvZiB0eXBlICciK0guS3godGhpcy4kdGkuYykudygwKSsiJyJ9fQpILmJRLnByb3Rv
+dHlwZT17fQpILmFMLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMKcmV0dXJuIG5l
+dyBILmE3KHMscy5nQShzKSxILkxoKHMpLkMoImE3PGFMLkU+IikpfSwKZ2wwOmZ1bmN0aW9uKGEpe3Jl
+dHVybiB0aGlzLmdBKHRoaXMpPT09MH0sCms6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscD10aGlzLG89
+cC5nQShwKQppZihiLmxlbmd0aCE9PTApe2lmKG89PT0wKXJldHVybiIiCnM9SC5FaihwLkUoMCwwKSkK
+aWYobyE9PXAuZ0EocCkpdGhyb3cgSC5iKFAuYTQocCkpCmZvcihyPXMscT0xO3E8bzsrK3Epe3I9citi
+K0guRWoocC5FKDAscSkpCmlmKG8hPT1wLmdBKHApKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gci5j
+aGFyQ29kZUF0KDApPT0wP3I6cn1lbHNle2ZvcihxPTAscj0iIjtxPG87KytxKXtyKz1ILkVqKHAuRSgw
+LHEpKQppZihvIT09cC5nQShwKSl0aHJvdyBILmIoUC5hNChwKSl9cmV0dXJuIHIuY2hhckNvZGVBdCgw
+KT09MD9yOnJ9fSwKZXY6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5HRygwLEguTGgodGhpcykuQygi
+YTIoYUwuRSkiKS5hKGIpKX0sCkUyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVy
+biBuZXcgSC5sSih0aGlzLHMuS3EoYykuQygiMShhTC5FKSIpLmEoYikscy5DKCJAPGFMLkU+IikuS3Eo
+YykuQygibEo8MSwyPiIpKX0sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEgucUModGhpcyxiLG51bGws
+SC5MaCh0aGlzKS5DKCJhTC5FIikpfSwKdHQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gUC5ZMSh0aGlzLCEw
+LEguTGgodGhpcykuQygiYUwuRSIpKX0sCmJyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnR0KGEsITAp
+fX0KSC5uSC5wcm90b3R5cGU9ewpIZDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyPXRoaXMuYgpQLmsx
+KHIsInN0YXJ0IikKcz10aGlzLmMKaWYocyE9bnVsbCl7UC5rMShzLCJlbmQiKQppZihyPnMpdGhyb3cg
+SC5iKFAuVEUociwwLHMsInN0YXJ0IixudWxsKSl9fSwKZ1VEOmZ1bmN0aW9uKCl7dmFyIHM9Si5IbSh0
+aGlzLmEpLHI9dGhpcy5jCmlmKHI9PW51bGx8fHI+cylyZXR1cm4gcwpyZXR1cm4gcn0sCmdBczpmdW5j
+dGlvbigpe3ZhciBzPUouSG0odGhpcy5hKSxyPXRoaXMuYgppZihyPnMpcmV0dXJuIHMKcmV0dXJuIHJ9
+LApnQTpmdW5jdGlvbihhKXt2YXIgcyxyPUouSG0odGhpcy5hKSxxPXRoaXMuYgppZihxPj1yKXJldHVy
+biAwCnM9dGhpcy5jCmlmKHM9PW51bGx8fHM+PXIpcmV0dXJuIHItcQppZih0eXBlb2YgcyE9PSJudW1i
+ZXIiKXJldHVybiBzLkhOKCkKcmV0dXJuIHMtcX0sCkU6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLHI9
+cy5nQXMoKStiCmlmKGI8MHx8cj49cy5nVUQoKSl0aHJvdyBILmIoUC5DZihiLHMsImluZGV4IixudWxs
+LG51bGwpKQpyZXR1cm4gSi5HQShzLmEscil9LAplUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT10aGlz
+ClAuazEoYiwiY291bnQiKQpzPXEuYitiCnI9cS5jCmlmKHIhPW51bGwmJnM+PXIpcmV0dXJuIG5ldyBI
+Lk1CKHEuJHRpLkMoIk1CPDE+IikpCnJldHVybiBILnFDKHEuYSxzLHIscS4kdGkuYyl9LAp0dDpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIscSxwPXRoaXMsbz1wLmIsbj1wLmEsbT1KLlU2KG4pLGw9bS5nQShuKSxr
+PXAuYwppZihrIT1udWxsJiZrPGwpbD1rCmlmKHR5cGVvZiBsIT09Im51bWJlciIpcmV0dXJuIGwuSE4o
+KQpzPWwtbwppZihzPD0wKXtuPUouUWkoMCxwLiR0aS5jKQpyZXR1cm4gbn1yPVAuTzgocyxtLkUobixv
+KSwhMSxwLiR0aS5jKQpmb3IocT0xO3E8czsrK3Epe0MuTm0uWTUocixxLG0uRShuLG8rcSkpCmlmKG0u
+Z0Eobik8bCl0aHJvdyBILmIoUC5hNChwKSl9cmV0dXJuIHJ9fQpILmE3LnByb3RvdHlwZT17CmdsOmZ1
+bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLmEscD1K
+LlU2KHEpLG89cC5nQShxKQppZihyLmIhPT1vKXRocm93IEguYihQLmE0KHEpKQpzPXIuYwppZihzPj1v
+KXtyLnNJKG51bGwpCnJldHVybiExfXIuc0kocC5FKHEscykpOysrci5jCnJldHVybiEwfSwKc0k6ZnVu
+Y3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KSC5pMS5wcm90b3R5
+cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVybiBuZXcgSC5NSChKLklUKHRo
+aXMuYSksdGhpcy5iLHMuQygiQDwxPiIpLktxKHMuUVsxXSkuQygiTUg8MSwyPiIpKX0sCmdBOmZ1bmN0
+aW9uKGEpe3JldHVybiBKLkhtKHRoaXMuYSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudVUodGhp
+cy5hKX0sCkU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5iLiQxKEouR0EodGhpcy5hLGIpKX19Ckgu
+eHkucHJvdG90eXBlPXskaWJROjF9CkguTUgucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzPXRo
+aXMscj1zLmIKaWYoci5GKCkpe3Muc0kocy5jLiQxKHIuZ2woKSkpCnJldHVybiEwfXMuc0kobnVsbCkK
+cmV0dXJuITF9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmF9LApzSTpmdW5jdGlvbihhKXt0aGlz
+LmE9dGhpcy4kdGkuQygiMj8iKS5hKGEpfX0KSC5sSi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXty
+ZXR1cm4gSi5IbSh0aGlzLmEpfSwKRTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmIuJDEoSi5HQSh0
+aGlzLmEsYikpfX0KSC5VNS5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguU08o
+Si5JVCh0aGlzLmEpLHRoaXMuYix0aGlzLiR0aS5DKCJTTzwxPiIpKX19CkguU08ucHJvdG90eXBlPXsK
+RjpmdW5jdGlvbigpe3ZhciBzLHIKZm9yKHM9dGhpcy5hLHI9dGhpcy5iO3MuRigpOylpZihILm9UKHIu
+JDEocy5nbCgpKSkpcmV0dXJuITAKcmV0dXJuITF9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmEu
+Z2woKX19CkguQU0ucHJvdG90eXBlPXsKZVI6ZnVuY3Rpb24oYSxiKXtQLmsxKGIsImNvdW50IikKcmV0
+dXJuIG5ldyBILkFNKHRoaXMuYSx0aGlzLmIrYixILkxoKHRoaXMpLkMoIkFNPDE+IikpfSwKZ206ZnVu
+Y3Rpb24oYSl7cmV0dXJuIG5ldyBILlUxKEouSVQodGhpcy5hKSx0aGlzLmIsSC5MaCh0aGlzKS5DKCJV
+MTwxPiIpKX19CkguZDUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7dmFyIHM9Si5IbSh0aGlzLmEp
+LXRoaXMuYgppZihzPj0wKXJldHVybiBzCnJldHVybiAwfSwKZVI6ZnVuY3Rpb24oYSxiKXtQLmsxKGIs
+ImNvdW50IikKcmV0dXJuIG5ldyBILmQ1KHRoaXMuYSx0aGlzLmIrYix0aGlzLiR0aSl9LAokaWJROjF9
+CkguVTEucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzLHIKZm9yKHM9dGhpcy5hLHI9MDtyPHRo
+aXMuYjsrK3Ipcy5GKCkKdGhpcy5iPTAKcmV0dXJuIHMuRigpfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4g
+dGhpcy5hLmdsKCl9fQpILk1CLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBDLkd3fSwK
+Z2wwOmZ1bmN0aW9uKGEpe3JldHVybiEwfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LApFOmZ1bmN0
+aW9uKGEsYil7dGhyb3cgSC5iKFAuVEUoYiwwLDAsImluZGV4IixudWxsKSl9LAplUjpmdW5jdGlvbihh
+LGIpe1AuazEoYiwiY291bnQiKQpyZXR1cm4gdGhpc319CkguRnUucHJvdG90eXBlPXsKRjpmdW5jdGlv
+bigpe3JldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXt0aHJvdyBILmIoSC5XcCgpKX0sCiRpQW46MX0KSC51
+Ni5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguSkIoSi5JVCh0aGlzLmEpLHRo
+aXMuJHRpLkMoIkpCPDE+IikpfX0KSC5KQi5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpm
+b3Iocz10aGlzLmEscj10aGlzLiR0aS5jO3MuRigpOylpZihyLmIocy5nbCgpKSlyZXR1cm4hMApyZXR1
+cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLmEuZ2woKSl9LAokaUFu
+OjF9CkguU1UucHJvdG90eXBlPXt9CkguUmUucHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe0gu
+TGgodGhpcykuQygiUmUuRSIpLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgYW4gdW5t
+b2RpZmlhYmxlIGxpc3QiKSl9fQpILncyLnByb3RvdHlwZT17fQpILnd2LnByb3RvdHlwZT17CmdpTzpm
+dW5jdGlvbihhKXt2YXIgcz10aGlzLl9oYXNoQ29kZQppZihzIT1udWxsKXJldHVybiBzCnM9NjY0NTk3
+KkouaGYodGhpcy5hKSY1MzY4NzA5MTEKdGhpcy5faGFzaENvZGU9cwpyZXR1cm4gc30sCnc6ZnVuY3Rp
+b24oYSl7cmV0dXJuJ1N5bWJvbCgiJytILkVqKHRoaXMuYSkrJyIpJ30sCkROOmZ1bmN0aW9uKGEsYil7
+aWYoYj09bnVsbClyZXR1cm4hMQpyZXR1cm4gYiBpbnN0YW5jZW9mIEgud3YmJnRoaXMuYT09Yi5hfSwK
+JGlHRDoxfQpILlFDLnByb3RvdHlwZT17fQpILlBELnByb3RvdHlwZT17fQpILldVLnByb3RvdHlwZT17
+CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKT09PTB9LAp3OmZ1bmN0aW9uKGEpe3Jl
+dHVybiBQLm5PKHRoaXMpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcy5jLmEo
+YikKcy5RWzFdLmEoYykKSC5kYygpCkguQmkodS5nKX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
+cy5xNCgwLEguTGgodGhpcykuQygiTjM8MSwyPiIpKX0sCnE0OmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhp
+cwpyZXR1cm4gUC5sMChmdW5jdGlvbigpe3ZhciByPWEKdmFyIHE9MCxwPTEsbyxuLG0sbCxrCnJldHVy
+biBmdW5jdGlvbiAkYXN5bmMkZ1B1KGMsZCl7aWYoYz09PTEpe289ZApxPXB9d2hpbGUodHJ1ZSlzd2l0
+Y2gocSl7Y2FzZSAwOm49cy5ndmMoKSxuPW4uZ20obiksbT1ILkxoKHMpLG09bS5DKCJAPDE+IikuS3Eo
+bS5RWzFdKS5DKCJOMzwxLDI+IikKY2FzZSAyOmlmKCFuLkYoKSl7cT0zCmJyZWFrfWw9bi5nbCgpCms9
+cy5xKDAsbCkKay50b1N0cmluZwpxPTQKcmV0dXJuIG5ldyBQLk4zKGwsayxtKQpjYXNlIDQ6cT0yCmJy
+ZWFrCmNhc2UgMzpyZXR1cm4gUC5UaCgpCmNhc2UgMTpyZXR1cm4gUC5ZbShvKX19fSxiKX0sCiRpWjA6
+MX0KSC5MUC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKeDQ6ZnVuY3Rp
+b24oYSl7aWYodHlwZW9mIGEhPSJzdHJpbmciKXJldHVybiExCmlmKCJfX3Byb3RvX18iPT09YSlyZXR1
+cm4hMQpyZXR1cm4gdGhpcy5iLmhhc093blByb3BlcnR5KGEpfSwKcTpmdW5jdGlvbihhLGIpe2lmKCF0
+aGlzLng0KGIpKXJldHVybiBudWxsCnJldHVybiB0aGlzLnFQKGIpfSwKcVA6ZnVuY3Rpb24oYSl7cmV0
+dXJuIHRoaXMuYltILmgoYSldfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG89SC5MaCh0aGlz
+KQpvLkMoIn4oMSwyKSIpLmEoYikKcz10aGlzLmMKZm9yKHI9cy5sZW5ndGgsbz1vLlFbMV0scT0wO3E8
+cjsrK3Epe3A9c1txXQpiLiQyKHAsby5hKHRoaXMucVAocCkpKX19LApndmM6ZnVuY3Rpb24oKXtyZXR1
+cm4gbmV3IEguWFIodGhpcyxILkxoKHRoaXMpLkMoIlhSPDE+IikpfX0KSC5YUi5wcm90b3R5cGU9ewpn
+bTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEuYwpyZXR1cm4gbmV3IEoubTEocyxzLmxlbmd0aCxILnQ2
+KHMpLkMoIm0xPDE+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jLmxlbmd0aH19Ckgu
+TEkucHJvdG90eXBlPXsKZ1dhOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5hCnJldHVybiBzfSwKZ25kOmZ1
+bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlmKG8uYz09PTEpcmV0dXJuIEMuaFUKcz1vLmQKcj1z
+Lmxlbmd0aC1vLmUubGVuZ3RoLW8uZgppZihyPT09MClyZXR1cm4gQy5oVQpxPVtdCmZvcihwPTA7cDxy
+OysrcCl7aWYocD49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxwKQpxLnB1c2goc1twXSl9cmV0dXJuIEou
+ekMocSl9LApnVm06ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhpcwppZihrLmMhPT0w
+KXJldHVybiBDLldPCnM9ay5lCnI9cy5sZW5ndGgKcT1rLmQKcD1xLmxlbmd0aC1yLWsuZgppZihyPT09
+MClyZXR1cm4gQy5XTwpvPW5ldyBILk41KHQuZW8pCmZvcihuPTA7bjxyOysrbil7aWYobj49cy5sZW5n
+dGgpcmV0dXJuIEguT0gocyxuKQptPXNbbl0KbD1wK24KaWYobDwwfHxsPj1xLmxlbmd0aClyZXR1cm4g
+SC5PSChxLGwpCm8uWTUoMCxuZXcgSC53dihtKSxxW2xdKX1yZXR1cm4gbmV3IEguUEQobyx0LmdGKX0s
+CiRpdlE6MX0KSC5Dai5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzCkguaChhKQpzPXRo
+aXMuYQpzLmI9cy5iKyIkIitILkVqKGEpCkMuTm0uaSh0aGlzLmIsYSkKQy5ObS5pKHRoaXMuYyxiKTsr
+K3MuYX0sCiRTOjEzfQpILmY5LnByb3RvdHlwZT17CnFTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlz
+LHA9bmV3IFJlZ0V4cChxLmEpLmV4ZWMoYSkKaWYocD09bnVsbClyZXR1cm4gbnVsbApzPU9iamVjdC5j
+cmVhdGUobnVsbCkKcj1xLmIKaWYociE9PS0xKXMuYXJndW1lbnRzPXBbcisxXQpyPXEuYwppZihyIT09
+LTEpcy5hcmd1bWVudHNFeHByPXBbcisxXQpyPXEuZAppZihyIT09LTEpcy5leHByPXBbcisxXQpyPXEu
+ZQppZihyIT09LTEpcy5tZXRob2Q9cFtyKzFdCnI9cS5mCmlmKHIhPT0tMSlzLnJlY2VpdmVyPXBbcisx
+XQpyZXR1cm4gc319CkguVzAucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIKaWYo
+cz09bnVsbClyZXR1cm4iTm9TdWNoTWV0aG9kRXJyb3I6ICIrSC5Faih0aGlzLmEpCnJldHVybiJOb1N1
+Y2hNZXRob2RFcnJvcjogbWV0aG9kIG5vdCBmb3VuZDogJyIrcysiJyBvbiBudWxsIn19CkguYXoucHJv
+dG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMscT0iTm9TdWNoTWV0aG9kRXJyb3I6IG1l
+dGhvZCBub3QgZm91bmQ6ICciLHA9ci5iCmlmKHA9PW51bGwpcmV0dXJuIk5vU3VjaE1ldGhvZEVycm9y
+OiAiK0guRWooci5hKQpzPXIuYwppZihzPT1udWxsKXJldHVybiBxK3ArIicgKCIrSC5FaihyLmEpKyIp
+IgpyZXR1cm4gcStwKyInIG9uICciK3MrIicgKCIrSC5FaihyLmEpKyIpIn19CkgudlYucHJvdG90eXBl
+PXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMubGVuZ3RoPT09MD8iRXJyb3IiOiJF
+cnJvcjogIitzfX0KSC50ZS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJUaHJvdyBvZiBu
+dWxsICgnIisodGhpcy5hPT09bnVsbD8ibnVsbCI6InVuZGVmaW5lZCIpKyInIGZyb20gSmF2YVNjcmlw
+dCkifSwKJGlSejoxfQpILmJxLnByb3RvdHlwZT17fQpILlhPLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
+YSl7dmFyIHMscj10aGlzLmIKaWYociE9bnVsbClyZXR1cm4gcgpyPXRoaXMuYQpzPXIhPT1udWxsJiZ0
+eXBlb2Ygcj09PSJvYmplY3QiP3Iuc3RhY2s6bnVsbApyZXR1cm4gdGhpcy5iPXM9PW51bGw/IiI6c30s
+CiRpR3o6MX0KSC5UcC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuY29uc3RydWN0
+b3Iscj1zPT1udWxsP251bGw6cy5uYW1lCnJldHVybiJDbG9zdXJlICciK0gucChyPT1udWxsPyJ1bmtu
+b3duIjpyKSsiJyJ9LAokaUVIOjEsCmdLdTpmdW5jdGlvbigpe3JldHVybiB0aGlzfSwKJEM6IiQxIiwK
+JFI6MSwKJEQ6bnVsbH0KSC5sYy5wcm90b3R5cGU9e30KSC56eC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMuJHN0YXRpY19uYW1lCmlmKHM9PW51bGwpcmV0dXJuIkNsb3N1cmUgb2YgdW5r
+bm93biBzdGF0aWMgbWV0aG9kIgpyZXR1cm4iQ2xvc3VyZSAnIitILnAocykrIicifX0KSC5yVC5wcm90
+b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMKaWYoYj09bnVsbClyZXR1cm4hMQppZihz
+PT09YilyZXR1cm4hMAppZighKGIgaW5zdGFuY2VvZiBILnJUKSlyZXR1cm4hMQpyZXR1cm4gcy5hPT09
+Yi5hJiZzLiRfdGFyZ2V0PT09Yi4kX3RhcmdldCYmcy5iPT09Yi5ifSwKZ2lPOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHI9dGhpcy5iCmlmKHI9PW51bGwpcz1ILmVRKHRoaXMuYSkKZWxzZSBzPXR5cGVvZiByIT09Im9i
+amVjdCI/Si5oZihyKTpILmVRKHIpCnI9SC5lUSh0aGlzLiRfdGFyZ2V0KQppZih0eXBlb2YgcyE9PSJu
+dW1iZXIiKXJldHVybiBzLlkoKQpyZXR1cm4oc15yKT4+PjB9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRo
+aXMuYgppZihzPT1udWxsKXM9dGhpcy5hCnJldHVybiJDbG9zdXJlICciK0guRWoodGhpcy4kX25hbWUp
+KyInIG9mICIrKCJJbnN0YW5jZSBvZiAnIitILkVqKEgubGgocykpKyInIil9fQpILkVxLnByb3RvdHlw
+ZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlJ1bnRpbWVFcnJvcjogIit0aGlzLmF9fQpILmtZLnByb3Rv
+dHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkFzc2VydGlvbiBmYWlsZWQ6ICIrUC5obCh0aGlzLmEp
+fX0KSC5rci5wcm90b3R5cGU9e30KSC5ONS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy5hfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmE9PT0wfSwKZ3ZjOmZ1bmN0aW9uKCl7
+cmV0dXJuIG5ldyBILmk1KHRoaXMsSC5MaCh0aGlzKS5DKCJpNTwxPiIpKX0sCng0OmZ1bmN0aW9uKGEp
+e3ZhciBzLHIKaWYodHlwZW9mIGE9PSJzdHJpbmciKXtzPXRoaXMuYgppZihzPT1udWxsKXJldHVybiEx
+CnJldHVybiB0aGlzLlh1KHMsYSl9ZWxzZXtyPXRoaXMuQ1goYSkKcmV0dXJuIHJ9fSwKQ1g6ZnVuY3Rp
+b24oYSl7dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJuITEKcmV0dXJuIHRoaXMuRmgodGhpcy5C
+dChzLEouaGYoYSkmMHgzZmZmZmZmKSxhKT49MH0sCnE6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxv
+PXRoaXMsbj1udWxsCmlmKHR5cGVvZiBiPT0ic3RyaW5nIil7cz1vLmIKaWYocz09bnVsbClyZXR1cm4g
+bgpyPW8uajIocyxiKQpxPXI9PW51bGw/bjpyLmIKcmV0dXJuIHF9ZWxzZSBpZih0eXBlb2YgYj09Im51
+bWJlciImJihiJjB4M2ZmZmZmZik9PT1iKXtwPW8uYwppZihwPT1udWxsKXJldHVybiBuCnI9by5qMihw
+LGIpCnE9cj09bnVsbD9uOnIuYgpyZXR1cm4gcX1lbHNlIHJldHVybiBvLmFhKGIpfSwKYWE6ZnVuY3Rp
+b24oYSl7dmFyIHMscixxPXRoaXMuZAppZihxPT1udWxsKXJldHVybiBudWxsCnM9dGhpcy5CdChxLEou
+aGYoYSkmMHgzZmZmZmZmKQpyPXRoaXMuRmgocyxhKQppZihyPDApcmV0dXJuIG51bGwKcmV0dXJuIHNb
+cl0uYn0sClk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9SC5MaChtKQps
+LmMuYShiKQpsLlFbMV0uYShjKQppZih0eXBlb2YgYj09InN0cmluZyIpe3M9bS5iCm0uRUgocz09bnVs
+bD9tLmI9bS56SygpOnMsYixjKX1lbHNlIGlmKHR5cGVvZiBiPT0ibnVtYmVyIiYmKGImMHgzZmZmZmZm
+KT09PWIpe3I9bS5jCm0uRUgocj09bnVsbD9tLmM9bS56SygpOnIsYixjKX1lbHNle3E9bS5kCmlmKHE9
+PW51bGwpcT1tLmQ9bS56SygpCnA9Si5oZihiKSYweDNmZmZmZmYKbz1tLkJ0KHEscCkKaWYobz09bnVs
+bCltLkVJKHEscCxbbS5IbihiLGMpXSkKZWxzZXtuPW0uRmgobyxiKQppZihuPj0wKW9bbl0uYj1jCmVs
+c2Ugby5wdXNoKG0uSG4oYixjKSl9fX0sCks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9dGhpcwpILkxo
+KHEpLkMoIn4oMSwyKSIpLmEoYikKcz1xLmUKcj1xLnIKZm9yKDtzIT1udWxsOyl7Yi4kMihzLmEscy5i
+KQppZihyIT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXMuY319LApFSDpmdW5jdGlvbihhLGIsYyl7
+dmFyIHMscj10aGlzLHE9SC5MaChyKQpxLmMuYShiKQpxLlFbMV0uYShjKQpzPXIuajIoYSxiKQppZihz
+PT1udWxsKXIuRUkoYSxiLHIuSG4oYixjKSkKZWxzZSBzLmI9Y30sCmtzOmZ1bmN0aW9uKCl7dGhpcy5y
+PXRoaXMucisxJjY3MTA4ODYzfSwKSG46ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLHI9SC5MaChzKSxx
+PW5ldyBILnZoKHIuYy5hKGEpLHIuUVsxXS5hKGIpKQppZihzLmU9PW51bGwpcy5lPXMuZj1xCmVsc2V7
+cj1zLmYKci50b1N0cmluZwpxLmQ9cgpzLmY9ci5jPXF9KytzLmEKcy5rcygpCnJldHVybiBxfSwKRmg6
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGE9PW51bGwpcmV0dXJuLTEKcz1hLmxlbmd0aApmb3Iocj0w
+O3I8czsrK3IpaWYoSi5STShhW3JdLmEsYikpcmV0dXJuIHIKcmV0dXJuLTF9LAp3OmZ1bmN0aW9uKGEp
+e3JldHVybiBQLm5PKHRoaXMpfSwKajI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYVtiXX0sCkJ0OmZ1bmN0
+aW9uKGEsYil7cmV0dXJuIGFbYl19LApFSTpmdW5jdGlvbihhLGIsYyl7YVtiXT1jfSwKcm46ZnVuY3Rp
+b24oYSxiKXtkZWxldGUgYVtiXX0sClh1OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuajIoYSxiKSE9
+bnVsbH0sCnpLOmZ1bmN0aW9uKCl7dmFyIHM9Ijxub24taWRlbnRpZmllci1rZXk+IixyPU9iamVjdC5j
+cmVhdGUobnVsbCkKdGhpcy5FSShyLHMscikKdGhpcy5ybihyLHMpCnJldHVybiByfSwKJGlGbzoxfQpI
+LnZoLnByb3RvdHlwZT17fQpILmk1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlz
+LmEuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmE9PT0wfSwKZ206ZnVuY3Rpb24oYSl7
+dmFyIHM9dGhpcy5hLHI9bmV3IEguTjYocyxzLnIsdGhpcy4kdGkuQygiTjY8MT4iKSkKci5jPXMuZQpy
+ZXR1cm4gcn0sCnRnOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS54NChiKX19CkguTjYucHJvdG90
+eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhp
+cyxxPXIuYQppZihyLmIhPT1xLnIpdGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM9PW51bGwpe3Iu
+c3FZKG51bGwpCnJldHVybiExfWVsc2V7ci5zcVkocy5hKQpyLmM9cy5jCnJldHVybiEwfX0sCnNxWTpm
+dW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpILmRDLnByb3Rv
+dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEoYSl9LAokUzo0fQpILndOLnByb3RvdHlw
+ZT17CiQyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYShhLGIpfSwKJFM6MzR9CkguVlgucHJvdG90
+eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYShILmgoYSkpfSwKJFM6MzJ9CkguVlIucHJv
+dG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iUmVnRXhwLyIrdGhpcy5hKyIvIit0aGlzLmIuZmxh
+Z3N9LApnSGM6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5jCmlmKHIhPW51bGwpcmV0dXJuIHIKcj1z
+LmIKcmV0dXJuIHMuYz1ILnY0KHMuYSxyLm11bHRpbGluZSwhci5pZ25vcmVDYXNlLHIudW5pY29kZSxy
+LmRvdEFsbCwhMCl9LApkZDpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgSC5LVyh0aGlzLGIsMCl9LApV
+WjpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5nSGMoKQpyLmxhc3RJbmRleD1iCnM9ci5leGVjKGEp
+CmlmKHM9PW51bGwpcmV0dXJuIG51bGwKcmV0dXJuIG5ldyBILkVLKHMpfSwKJGl2WDoxLAokaXdMOjF9
+CkguRUsucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3ZhciBzCkgudVAoYikKcz10aGlzLmIKaWYo
+Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1cm4gc1tiXX0sCiRpT2Q6MSwKJGlpYjoxfQpI
+LktXLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5QYih0aGlzLmEsdGhpcy5i
+LHRoaXMuYyl9fQpILlBiLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6
+ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9bS5iCmlmKGw9PW51bGwpcmV0dXJuITEK
+cz1tLmMKcj1sLmxlbmd0aAppZihzPD1yKXtxPW0uYQpwPXEuVVoobCxzKQppZihwIT1udWxsKXttLmQ9
+cApzPXAuYgpvPXMuaW5kZXgKbj1vK3NbMF0ubGVuZ3RoCmlmKG89PT1uKXtpZihxLmIudW5pY29kZSl7
+cz1tLmMKcT1zKzEKaWYocTxyKXtzPUMueEIuTyhsLHMpCmlmKHM+PTU1Mjk2JiZzPD01NjMxOSl7cz1D
+LnhCLk8obCxxKQpzPXM+PTU2MzIwJiZzPD01NzM0M31lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0h
+MQpuPShzP24rMTpuKSsxfW0uYz1uCnJldHVybiEwfX1tLmI9bS5kPW51bGwKcmV0dXJuITF9LAokaUFu
+OjF9CkgudFEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYiE9PTApSC52KFAu
+TzcoYixudWxsKSkKcmV0dXJuIHRoaXMuY30sCiRpT2Q6MX0KSC51bi5wcm90b3R5cGU9ewpnbTpmdW5j
+dGlvbihhKXtyZXR1cm4gbmV3IEguU2QodGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5TZC5wcm90b3R5
+cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMscD1xLmMsbz1xLmIsbj1vLmxlbmd0aCxtPXEu
+YSxsPW0ubGVuZ3RoCmlmKHArbj5sKXtxLmQ9bnVsbApyZXR1cm4hMX1zPW0uaW5kZXhPZihvLHApCmlm
+KHM8MCl7cS5jPWwrMQpxLmQ9bnVsbApyZXR1cm4hMX1yPXMrbgpxLmQ9bmV3IEgudFEocyxvKQpxLmM9
+cj09PXEuYz9yKzE6cgpyZXR1cm4hMH0sCmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5kCnMudG9TdHJp
+bmcKcmV0dXJuIHN9LAokaUFuOjF9CkguRVQucHJvdG90eXBlPXskaUVUOjEsJGlBUzoxfQpILkxaLnBy
+b3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCiRpWGo6MX0KSC5EZy5wcm90
+b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFb
+Yl19LApZNTpmdW5jdGlvbihhLGIsYyl7SC5HSChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwK
+JGliUToxLAokaWNYOjEsCiRpek06MX0KSC5QZy5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7
+SC51UChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0K
+SC54ai5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkK
+cmV0dXJuIGFbYl19fQpILmRFLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2Qo
+YixhLGEubGVuZ3RoKQpyZXR1cm4gYVtiXX19CkguWkEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIp
+e0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kVC5wcm90b3R5cGU9ewpx
+OmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILlBx
+LnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1
+cm4gYVtiXX19CkguZUUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwK
+cTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5W
+Ni5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEs
+Yil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LAokaVY2OjEsCiRpbjY6MX0K
+SC5SRy5wcm90b3R5cGU9e30KSC5WUC5wcm90b3R5cGU9e30KSC5XQi5wcm90b3R5cGU9e30KSC5aRy5w
+cm90b3R5cGU9e30KSC5KYy5wcm90b3R5cGU9ewpDOmZ1bmN0aW9uKGEpe3JldHVybiBILmNFKHYudHlw
+ZVVuaXZlcnNlLHRoaXMsYSl9LApLcTpmdW5jdGlvbihhKXtyZXR1cm4gSC52NSh2LnR5cGVVbml2ZXJz
+ZSx0aGlzLGEpfX0KSC5HLnByb3RvdHlwZT17fQpILmxZLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7
+cmV0dXJuIEguZG0odGhpcy5hLG51bGwpfX0KSC5rUy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3Jl
+dHVybiB0aGlzLmF9fQpILmlNLnByb3RvdHlwZT17fQpQLnRoLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMuYSxyPXMuYQpzLmE9bnVsbApyLiQwKCl9LAokUzoxMH0KUC5oYS5wcm90b3R5
+cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyCnRoaXMuYS5hPXQuTS5hKGEpCnM9dGhpcy5iCnI9dGhp
+cy5jCnMuZmlyc3RDaGlsZD9zLnJlbW92ZUNoaWxkKHIpOnMuYXBwZW5kQ2hpbGQocil9LAokUzo1M30K
+UC5Wcy5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS4kMCgpfSwKJEM6IiQwIiwKJFI6MCwK
+JFM6Mn0KUC5GdC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS4kMCgpfSwKJEM6IiQwIiwK
+JFI6MCwKJFM6Mn0KUC5XMy5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhLGIpe2lmKHNlbGYuc2V0VGlt
+ZW91dCE9bnVsbClzZWxmLnNldFRpbWVvdXQoSC50UihuZXcgUC55SCh0aGlzLGIpLDApLGEpCmVsc2Ug
+dGhyb3cgSC5iKFAuTDQoImBzZXRUaW1lb3V0KClgIG5vdCBmb3VuZC4iKSl9fQpQLnlILnByb3RvdHlw
+ZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5iLiQwKCl9LAokQzoiJDAiLAokUjowLAokUzowfQpQLmloLnBy
+b3RvdHlwZT17CmFNOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLHE9ci4kdGkKcS5DKCIxLz8iKS5h
+KGIpCmlmKCFyLmIpci5hLlhmKGIpCmVsc2V7cz1yLmEKaWYocS5DKCJiODwxPiIpLmIoYikpcy5jVShi
+KQplbHNlIHMuWDIocS5jLmEoYikpfX0sCncwOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYj09bnVsbCli
+PVAudjAoYSkKcz10aGlzLmEKaWYodGhpcy5iKXMuWkwoYSxiKQplbHNlIHMuTmsoYSxiKX19ClAuV00u
+cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMigwLGEpfSwKJFM6NDN9ClAu
+U1gucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuJDIoMSxuZXcgSC5icShhLHQubC5h
+KGIpKSl9LAokQzoiJDIiLAokUjoyLAokUzo1NX0KUC5Hcy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihh
+LGIpe3RoaXMuYShILnVQKGEpLGIpfSwKJFM6MjR9ClAuRnkucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
+KXtyZXR1cm4iSXRlcmF0aW9uTWFya2VyKCIrdGhpcy5iKyIsICIrSC5Faih0aGlzLmEpKyIpIn19ClAu
+R1YucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLmMKaWYocz09bnVsbClyZXR1cm4g
+dGhpcy4kdGkuYy5hKHRoaXMuYikKcmV0dXJuIHMuZ2woKX0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxyLHEs
+cCxvLG4sbT10aGlzCmZvcihzPW0uJHRpLkMoIkFuPDE+Iik7ITA7KXtyPW0uYwppZihyIT1udWxsKWlm
+KHIuRigpKXJldHVybiEwCmVsc2UgbS5zWDkobnVsbCkKcT1mdW5jdGlvbihhLGIsYyl7dmFyIGwsaz1i
+CndoaWxlKHRydWUpdHJ5e3JldHVybiBhKGssbCl9Y2F0Y2goail7bD1qCms9Y319KG0uYSwwLDEpCmlm
+KHEgaW5zdGFuY2VvZiBQLkZ5KXtwPXEuYgppZihwPT09Mil7bz1tLmQKaWYobz09bnVsbHx8by5sZW5n
+dGg9PT0wKXttLnNFQyhudWxsKQpyZXR1cm4hMX1pZigwPj1vLmxlbmd0aClyZXR1cm4gSC5PSChvLC0x
+KQptLmE9by5wb3AoKQpjb250aW51ZX1lbHNle3I9cS5hCmlmKHA9PT0zKXRocm93IHIKZWxzZXtuPXMu
+YShKLklUKHIpKQppZihuIGluc3RhbmNlb2YgUC5HVil7cj1tLmQKaWYocj09bnVsbClyPW0uZD1bXQpD
+Lk5tLmkocixtLmEpCm0uYT1uLmEKY29udGludWV9ZWxzZXttLnNYOShuKQpjb250aW51ZX19fX1lbHNl
+e20uc0VDKHEpCnJldHVybiEwfX1yZXR1cm4hMX0sCnNFQzpmdW5jdGlvbihhKXt0aGlzLmI9dGhpcy4k
+dGkuQygiMT8iKS5hKGEpfSwKc1g5OmZ1bmN0aW9uKGEpe3RoaXMuYz10aGlzLiR0aS5DKCJBbjwxPj8i
+KS5hKGEpfSwKJGlBbjoxfQpQLnE0LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcg
+UC5HVih0aGlzLmEoKSx0aGlzLiR0aS5DKCJHVjwxPiIpKX19ClAuQ3cucHJvdG90eXBlPXsKdzpmdW5j
+dGlvbihhKXtyZXR1cm4gSC5Faih0aGlzLmEpfSwKJGlYUzoxLApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4g
+dGhpcy5ifX0KUC5QZi5wcm90b3R5cGU9ewp3MDpmdW5jdGlvbihhLGIpe3ZhciBzCkguY2IoYSwiZXJy
+b3IiLHQuSykKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBILmIoUC5QVigiRnV0dXJlIGFscmVhZHkg
+Y29tcGxldGVkIikpCmlmKGI9PW51bGwpYj1QLnYwKGEpCnMuTmsoYSxiKX0sCnBtOmZ1bmN0aW9uKGEp
+e3JldHVybiB0aGlzLncwKGEsbnVsbCl9fQpQLlpmLnByb3RvdHlwZT17CmFNOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscj10aGlzLiR0aQpyLkMoIjEvPyIpLmEoYikKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBI
+LmIoUC5QVigiRnV0dXJlIGFscmVhZHkgY29tcGxldGVkIikpCnMuWGYoci5DKCIxLyIpLmEoYikpfX0K
+UC5GZS5wcm90b3R5cGU9ewpIUjpmdW5jdGlvbihhKXtpZigodGhpcy5jJjE1KSE9PTYpcmV0dXJuITAK
+cmV0dXJuIHRoaXMuYi5iLmJ2KHQuYWwuYSh0aGlzLmQpLGEuYSx0LnksdC5LKX0sCkt3OmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMuZSxyPXQueixxPXQuSyxwPXRoaXMuJHRpLkMoIjIvIiksbz10aGlzLmIuYgpp
+Zih0LmFnLmIocykpcmV0dXJuIHAuYShvLnJwKHMsYS5hLGEuYixyLHEsdC5sKSkKZWxzZSByZXR1cm4g
+cC5hKG8uYnYodC5iSS5hKHMpLGEuYSxyLHEpKX19ClAudnMucHJvdG90eXBlPXsKU3E6ZnVuY3Rpb24o
+YSxiLGMpe3ZhciBzLHIscSxwPXRoaXMuJHRpCnAuS3EoYykuQygiMS8oMikiKS5hKGEpCnM9JC5YMwpp
+ZihzIT09Qy5OVSl7Yy5DKCJAPDAvPiIpLktxKHAuYykuQygiMSgyKSIpLmEoYSkKaWYoYiE9bnVsbCli
+PVAuVkgoYixzKX1yPW5ldyBQLnZzKHMsYy5DKCJ2czwwPiIpKQpxPWI9PW51bGw/MTozCnRoaXMueGYo
+bmV3IFAuRmUocixxLGEsYixwLkMoIkA8MT4iKS5LcShjKS5DKCJGZTwxLDI+IikpKQpyZXR1cm4gcn0s
+Clc3OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuU3EoYSxudWxsLGIpfSwKUWQ6ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBzLHI9dGhpcy4kdGkKci5LcShjKS5DKCIxLygyKSIpLmEoYSkKcz1uZXcgUC52cygkLlgz
+LGMuQygidnM8MD4iKSkKdGhpcy54ZihuZXcgUC5GZShzLDE5LGEsYixyLkMoIkA8MT4iKS5LcShjKS5D
+KCJGZTwxLDI+IikpKQpyZXR1cm4gc30sCnhmOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcyxxPXIuYQpp
+ZihxPD0xKXthLmE9dC5GLmEoci5jKQpyLmM9YX1lbHNle2lmKHE9PT0yKXtzPXQuYy5hKHIuYykKcT1z
+LmEKaWYocTw0KXtzLnhmKGEpCnJldHVybn1yLmE9cQpyLmM9cy5jfVAuVGsobnVsbCxudWxsLHIuYix0
+Lk0uYShuZXcgUC5kYShyLGEpKSl9fSwKalE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG09dGhp
+cyxsPXt9CmwuYT1hCmlmKGE9PW51bGwpcmV0dXJuCnM9bS5hCmlmKHM8PTEpe3I9dC5GLmEobS5jKQpt
+LmM9YQppZihyIT1udWxsKXtxPWEuYQpmb3IocD1hO3EhPW51bGw7cD1xLHE9bylvPXEuYQpwLmE9cn19
+ZWxzZXtpZihzPT09Mil7bj10LmMuYShtLmMpCnM9bi5hCmlmKHM8NCl7bi5qUShhKQpyZXR1cm59bS5h
+PXMKbS5jPW4uY31sLmE9bS5OOChhKQpQLlRrKG51bGwsbnVsbCxtLmIsdC5NLmEobmV3IFAub1EobCxt
+KSkpfX0sCmFoOmZ1bmN0aW9uKCl7dmFyIHM9dC5GLmEodGhpcy5jKQp0aGlzLmM9bnVsbApyZXR1cm4g
+dGhpcy5OOChzKX0sCk44OmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1hLHI9bnVsbDtzIT1udWxs
+O3I9cyxzPXEpe3E9cy5hCnMuYT1yfXJldHVybiByfSwKZWM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9
+dGhpcwpwLmE9MQp0cnl7YS5TcShuZXcgUC5wVihwKSxuZXcgUC5VNyhwKSx0LlApfWNhdGNoKHEpe3M9
+SC5SdShxKQpyPUgudHMocSkKUC5yYihuZXcgUC52cihwLHMscikpfX0sClgyOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHI9dGhpcwpyLiR0aS5jLmEoYSkKcz1yLmFoKCkKci5hPTQKci5jPWEKUC5IWihyLHMpfSwKWkw6
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9dGhpcwp0LmwuYShiKQpzPXEuYWgoKQpyPVAuVGwoYSxiKQpx
+LmE9OApxLmM9cgpQLkhaKHEscyl9LApYZjpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiR0aQpzLkMoIjEv
+IikuYShhKQppZihzLkMoImI4PDE+IikuYihhKSl7dGhpcy5jVShhKQpyZXR1cm59dGhpcy53VShzLmMu
+YShhKSl9LAp3VTpmdW5jdGlvbihhKXt2YXIgcz10aGlzCnMuJHRpLmMuYShhKQpzLmE9MQpQLlRrKG51
+bGwsbnVsbCxzLmIsdC5NLmEobmV3IFAucnQocyxhKSkpfSwKY1U6ZnVuY3Rpb24oYSl7dmFyIHM9dGhp
+cyxyPXMuJHRpCnIuQygiYjg8MT4iKS5hKGEpCmlmKHIuYihhKSl7aWYoYS5hPT09OCl7cy5hPTEKUC5U
+ayhudWxsLG51bGwscy5iLHQuTS5hKG5ldyBQLktGKHMsYSkpKX1lbHNlIFAuQTkoYSxzKQpyZXR1cm59
+cy5lYyhhKX0sCk5rOmZ1bmN0aW9uKGEsYil7dGhpcy5hPTEKUC5UayhudWxsLG51bGwsdGhpcy5iLHQu
+TS5hKG5ldyBQLlpMKHRoaXMsYSxiKSkpfSwKJGliODoxfQpQLmRhLnByb3RvdHlwZT17CiQwOmZ1bmN0
+aW9uKCl7UC5IWih0aGlzLmEsdGhpcy5iKX0sCiRTOjB9ClAub1EucHJvdG90eXBlPXsKJDA6ZnVuY3Rp
+b24oKXtQLkhaKHRoaXMuYix0aGlzLmEuYSl9LAokUzowfQpQLnBWLnByb3RvdHlwZT17CiQxOmZ1bmN0
+aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMuYQpwLmE9MAp0cnl7cC5YMihwLiR0aS5jLmEoYSkpfWNhdGNo
+KHEpe3M9SC5SdShxKQpyPUgudHMocSkKcC5aTChzLHIpfX0sCiRTOjEwfQpQLlU3LnByb3RvdHlwZT17
+CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5hLlpMKGEsdC5sLmEoYikpfSwKJEM6IiQyIiwKJFI6MiwKJFM6
+Mjh9ClAudnIucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuWkwodGhpcy5iLHRoaXMuYyl9
+LAokUzowfQpQLnJ0LnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlgyKHRoaXMuYil9LAok
+UzowfQpQLktGLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7UC5BOSh0aGlzLmIsdGhpcy5hKX0sCiRT
+OjB9ClAuWkwucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuWkwodGhpcy5iLHRoaXMuYyl9
+LAokUzowfQpQLlJULnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhp
+cyxsPW51bGwKdHJ5e3E9bS5hLmEKbD1xLmIuYi56eih0LmZPLmEocS5kKSx0LnopfWNhdGNoKHApe3M9
+SC5SdShwKQpyPUgudHMocCkKaWYobS5jKXtxPXQubi5hKG0uYi5hLmMpLmEKbz1zCm89cT09bnVsbD9v
+PT1udWxsOnE9PT1vCnE9b31lbHNlIHE9ITEKbz1tLmEKaWYocSlvLmM9dC5uLmEobS5iLmEuYykKZWxz
+ZSBvLmM9UC5UbChzLHIpCm8uYj0hMApyZXR1cm59aWYobCBpbnN0YW5jZW9mIFAudnMmJmwuYT49NCl7
+aWYobC5hPT09OCl7cT1tLmEKcS5jPXQubi5hKGwuYykKcS5iPSEwfXJldHVybn1pZih0LmUuYihsKSl7
+bj1tLmIuYQpxPW0uYQpxLmM9bC5XNyhuZXcgUC5qWihuKSx0LnopCnEuYj0hMX19LAokUzowfQpQLmpa
+LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LAokUzoyOX0KUC5ycS5wcm90
+b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGwKdHJ5e3E9dGhpcy5hCnA9cS5h
+Cm89cC4kdGkKbj1vLmMKbT1uLmEodGhpcy5iKQpxLmM9cC5iLmIuYnYoby5DKCIyLygxKSIpLmEocC5k
+KSxtLG8uQygiMi8iKSxuKX1jYXRjaChsKXtzPUguUnUobCkKcj1ILnRzKGwpCnE9dGhpcy5hCnEuYz1Q
+LlRsKHMscikKcS5iPSEwfX0sCiRTOjB9ClAuUlcucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIg
+cyxyLHEscCxvLG4sbSxsLGs9dGhpcwp0cnl7cz10Lm4uYShrLmEuYS5jKQpwPWsuYgppZihILm9UKHAu
+YS5IUihzKSkmJnAuYS5lIT1udWxsKXtwLmM9cC5hLkt3KHMpCnAuYj0hMX19Y2F0Y2gobyl7cj1ILlJ1
+KG8pCnE9SC50cyhvKQpwPXQubi5hKGsuYS5hLmMpCm49cC5hCm09cgpsPWsuYgppZihuPT1udWxsP209
+PW51bGw6bj09PW0pbC5jPXAKZWxzZSBsLmM9UC5UbChyLHEpCmwuYj0hMH19LAokUzowfQpQLk9NLnBy
+b3RvdHlwZT17fQpQLnFoLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9
+e30sbz1uZXcgUC52cygkLlgzLHQuZkopCnAuYT0wCnM9SC5MaChxKQpyPXMuQygifigxKT8iKS5hKG5l
+dyBQLkI1KHAscSkpCnQuWi5hKG5ldyBQLnVPKHAsbykpClcuSkUocS5hLHEuYixyLCExLHMuYykKcmV0
+dXJuIG99fQpQLkI1LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe0guTGgodGhpcy5iKS5jLmEoYSk7
+Kyt0aGlzLmEuYX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIEguTGgodGhpcy5iKS5DKCJ+KDEpIil9fQpQ
+LnVPLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5iLHI9cy4kdGkscT1yLkMoIjEv
+IikuYSh0aGlzLmEuYSkscD1zLmFoKCkKci5jLmEocSkKcy5hPTQKcy5jPXEKUC5IWihzLHApfSwKJFM6
+MH0KUC5NTy5wcm90b3R5cGU9e30KUC5rVC5wcm90b3R5cGU9e30KUC54SS5wcm90b3R5cGU9e30KUC5t
+MC5wcm90b3R5cGU9eyRpUW06MX0KUC5Fdi5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzPUgu
+Yih0aGlzLmEpCnMuc3RhY2s9Si53KHRoaXMuYikKdGhyb3cgc30sCiRTOjB9ClAuSmkucHJvdG90eXBl
+PXsKYkg6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuTS5hKGEpCnRyeXtpZihDLk5VPT09JC5YMyl7YS4k
+MCgpCnJldHVybn1QLlQ4KG51bGwsbnVsbCx0aGlzLGEsdC5IKX1jYXRjaChxKXtzPUguUnUocSkKcj1I
+LnRzKHEpClAuU2kocyx0LmwuYShyKSl9fSwKRGw6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpjLkMo
+In4oMCkiKS5hKGEpCmMuYShiKQp0cnl7aWYoQy5OVT09PSQuWDMpe2EuJDEoYikKcmV0dXJufVAueXYo
+bnVsbCxudWxsLHRoaXMsYSxiLHQuSCxjKX1jYXRjaChxKXtzPUguUnUocSkKcj1ILnRzKHEpClAuU2ko
+cyx0LmwuYShyKSl9fSwKR1k6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLlZwKHRoaXMsdC5NLmEoYSkp
+fSwKUHk6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IFAuT1IodGhpcyxiLkMoIn4oMCkiKS5hKGEpLGIp
+fSwKcTpmdW5jdGlvbihhLGIpe3JldHVybiBudWxsfSwKeno6ZnVuY3Rpb24oYSxiKXtiLkMoIjAoKSIp
+LmEoYSkKaWYoJC5YMz09PUMuTlUpcmV0dXJuIGEuJDAoKQpyZXR1cm4gUC5UOChudWxsLG51bGwsdGhp
+cyxhLGIpfSwKYnY6ZnVuY3Rpb24oYSxiLGMsZCl7Yy5DKCJAPDA+IikuS3EoZCkuQygiMSgyKSIpLmEo
+YSkKZC5hKGIpCmlmKCQuWDM9PT1DLk5VKXJldHVybiBhLiQxKGIpCnJldHVybiBQLnl2KG51bGwsbnVs
+bCx0aGlzLGEsYixjLGQpfSwKcnA6ZnVuY3Rpb24oYSxiLGMsZCxlLGYpe2QuQygiQDwwPiIpLktxKGUp
+LktxKGYpLkMoIjEoMiwzKSIpLmEoYSkKZS5hKGIpCmYuYShjKQppZigkLlgzPT09Qy5OVSlyZXR1cm4g
+YS4kMihiLGMpCnJldHVybiBQLlF4KG51bGwsbnVsbCx0aGlzLGEsYixjLGQsZSxmKX0sCkxqOmZ1bmN0
+aW9uKGEsYixjLGQpe3JldHVybiBiLkMoIkA8MD4iKS5LcShjKS5LcShkKS5DKCIxKDIsMykiKS5hKGEp
+fX0KUC5WcC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmEuYkgodGhpcy5iKX0s
+CiRTOjB9ClAuT1IucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCnJldHVybiB0
+aGlzLmEuRGwodGhpcy5iLHMuYShhKSxzKX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYy5DKCJ+
+KDApIil9fQpQLmI2LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1uZXcgUC5s
+bShzLHMucixILkxoKHMpLkMoImxtPDE+IikpCnIuYz1zLmUKcmV0dXJuIHJ9LApnQTpmdW5jdGlvbihh
+KXtyZXR1cm4gdGhpcy5hfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmE9PT0wfSwKZ29yOmZ1
+bmN0aW9uKGEpe3JldHVybiB0aGlzLmEhPT0wfSwKdGc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKHR5
+cGVvZiBiPT0ic3RyaW5nIiYmYiE9PSJfX3Byb3RvX18iKXtzPXRoaXMuYgppZihzPT1udWxsKXJldHVy
+biExCnJldHVybiB0Lm0uYShzW2JdKSE9bnVsbH1lbHNle3I9dGhpcy5QUihiKQpyZXR1cm4gcn19LApQ
+UjpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmQKaWYocz09bnVsbClyZXR1cm4hMQpyZXR1cm4gdGhpcy5E
+RihzW3RoaXMuTihhKV0sYSk+PTB9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKSC5MaChx
+KS5jLmEoYikKaWYodHlwZW9mIGI9PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpe3M9cS5iCnJldHVy
+biBxLmJRKHM9PW51bGw/cS5iPVAuVDIoKTpzLGIpfWVsc2UgaWYodHlwZW9mIGI9PSJudW1iZXIiJiYo
+YiYxMDczNzQxODIzKT09PWIpe3I9cS5jCnJldHVybiBxLmJRKHI9PW51bGw/cS5jPVAuVDIoKTpyLGIp
+fWVsc2UgcmV0dXJuIHEuQjcoYil9LApCNzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD10aGlzCkguTGgo
+cCkuYy5hKGEpCnM9cC5kCmlmKHM9PW51bGwpcz1wLmQ9UC5UMigpCnI9cC5OKGEpCnE9c1tyXQppZihx
+PT1udWxsKXNbcl09W3AueW8oYSldCmVsc2V7aWYocC5ERihxLGEpPj0wKXJldHVybiExCnEucHVzaChw
+LnlvKGEpKX1yZXR1cm4hMH0sClI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzCmlmKHR5cGVvZiBiPT0i
+c3RyaW5nIiYmYiE9PSJfX3Byb3RvX18iKXJldHVybiBzLkgocy5iLGIpCmVsc2UgaWYodHlwZW9mIGI9
+PSJudW1iZXIiJiYoYiYxMDczNzQxODIzKT09PWIpcmV0dXJuIHMuSChzLmMsYikKZWxzZSByZXR1cm4g
+cy5xZyhiKX0sCnFnOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG89dGhpcyxuPW8uZAppZihuPT1udWxs
+KXJldHVybiExCnM9by5OKGEpCnI9bltzXQpxPW8uREYocixhKQppZihxPDApcmV0dXJuITEKcD1yLnNw
+bGljZShxLDEpWzBdCmlmKDA9PT1yLmxlbmd0aClkZWxldGUgbltzXQpvLkcocCkKcmV0dXJuITB9LApi
+UTpmdW5jdGlvbihhLGIpe0guTGgodGhpcykuYy5hKGIpCmlmKHQubS5hKGFbYl0pIT1udWxsKXJldHVy
+biExCmFbYl09dGhpcy55byhiKQpyZXR1cm4hMH0sCkg6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihhPT1u
+dWxsKXJldHVybiExCnM9dC5tLmEoYVtiXSkKaWYocz09bnVsbClyZXR1cm4hMQp0aGlzLkcocykKZGVs
+ZXRlIGFbYl0KcmV0dXJuITB9LApTOmZ1bmN0aW9uKCl7dGhpcy5yPXRoaXMucisxJjEwNzM3NDE4MjN9
+LAp5bzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMscT1uZXcgUC5ibihILkxoKHIpLmMuYShhKSkKaWYo
+ci5lPT1udWxsKXIuZT1yLmY9cQplbHNle3M9ci5mCnMudG9TdHJpbmcKcS5jPXMKci5mPXMuYj1xfSsr
+ci5hCnIuUygpCnJldHVybiBxfSwKRzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9YS5jLHE9YS5iCmlm
+KHI9PW51bGwpcy5lPXEKZWxzZSByLmI9cQppZihxPT1udWxsKXMuZj1yCmVsc2UgcS5jPXI7LS1zLmEK
+cy5TKCl9LApOOmZ1bmN0aW9uKGEpe3JldHVybiBKLmhmKGEpJjEwNzM3NDE4MjN9LApERjpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIKaWYoYT09bnVsbClyZXR1cm4tMQpzPWEubGVuZ3RoCmZvcihyPTA7cjxzOysr
+cilpZihKLlJNKGFbcl0uYSxiKSlyZXR1cm4gcgpyZXR1cm4tMX19ClAuYm4ucHJvdG90eXBlPXt9ClAu
+bG0ucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3Zh
+ciBzPXRoaXMscj1zLmMscT1zLmEKaWYocy5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQplbHNlIGlm
+KHI9PW51bGwpe3Muc2oobnVsbCkKcmV0dXJuITF9ZWxzZXtzLnNqKHMuJHRpLkMoIjE/IikuYShyLmEp
+KQpzLmM9ci5iCnJldHVybiEwfX0sCnNqOmZ1bmN0aW9uKGEpe3RoaXMuZD10aGlzLiR0aS5DKCIxPyIp
+LmEoYSl9LAokaUFuOjF9ClAubVcucHJvdG90eXBlPXt9ClAudXkucHJvdG90eXBlPXskaWJROjEsJGlj
+WDoxLCRpek06MX0KUC5sRC5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguYTco
+YSx0aGlzLmdBKGEpLEgueksoYSkuQygiYTc8bEQuRT4iKSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJu
+IHRoaXMucShhLGIpfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC56SyhhKS5DKCJ+KGxELkUpIiku
+YShiKQpzPXRoaXMuZ0EoYSkKZm9yKHI9MDtyPHM7KytyKXtiLiQxKHRoaXMucShhLHIpKQppZihzIT09
+dGhpcy5nQShhKSl0aHJvdyBILmIoUC5hNChhKSl9fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlz
+LmdBKGEpPT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4hdGhpcy5nbDAoYSl9LApFMjpmdW5jdGlv
+bihhLGIsYyl7dmFyIHM9SC56SyhhKQpyZXR1cm4gbmV3IEgubEooYSxzLktxKGMpLkMoIjEobEQuRSki
+KS5hKGIpLHMuQygiQDxsRC5FPiIpLktxKGMpLkMoImxKPDEsMj4iKSl9LAplUjpmdW5jdGlvbihhLGIp
+e3JldHVybiBILnFDKGEsYixudWxsLEgueksoYSkuQygibEQuRSIpKX0sCmRyOmZ1bmN0aW9uKGEsYil7
+cmV0dXJuIG5ldyBILmpWKGEsSC56SyhhKS5DKCJAPGxELkU+IikuS3EoYikuQygialY8MSwyPiIpKX0s
+CmR1OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzCkgueksoYSkuQygibEQuRT8iKS5hKGQpClAuakIoYixj
+LHRoaXMuZ0EoYSkpCmZvcihzPWI7czxjOysrcyl0aGlzLlk1KGEscyxkKX0sCnc6ZnVuY3Rpb24oYSl7
+cmV0dXJuIFAueChhLCJbIiwiXSIpfX0KUC5pbC5wcm90b3R5cGU9e30KUC5yYS5wcm90b3R5cGU9ewok
+MjpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5hCmlmKCFyLmEpdGhpcy5iLmErPSIsICIKci5hPSEx
+CnI9dGhpcy5iCnM9ci5hKz1ILkVqKGEpCnIuYT1zKyI6ICIKci5hKz1ILkVqKGIpfSwKJFM6MTF9ClAu
+WWsucHJvdG90eXBlPXsKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC5MaCh0aGlzKS5DKCJ+KFlrLkss
+WWsuVikiKS5hKGIpCmZvcihzPUouSVQodGhpcy5ndmMoKSk7cy5GKCk7KXtyPXMuZ2woKQpiLiQyKHIs
+dGhpcy5xKDAscikpfX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gSi5NMSh0aGlzLmd2YygpLG5ldyBQ
+LnlRKHRoaXMpLEguTGgodGhpcykuQygiTjM8WWsuSyxZay5WPiIpKX0sCng0OmZ1bmN0aW9uKGEpe3Jl
+dHVybiBKLnpsKHRoaXMuZ3ZjKCksYSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gSi5IbSh0aGlzLmd2
+YygpKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmd2YygpKX0sCnc6ZnVuY3Rpb24o
+YSl7cmV0dXJuIFAubk8odGhpcyl9LAokaVowOjF9ClAueVEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcy5hLHI9SC5MaChzKQpyLkMoIllrLksiKS5hKGEpCnJldHVybiBuZXcgUC5OMyhh
+LHMucSgwLGEpLHIuQygiQDxZay5LPiIpLktxKHIuQygiWWsuViIpKS5DKCJOMzwxLDI+IikpfSwKJFM6
+ZnVuY3Rpb24oKXtyZXR1cm4gSC5MaCh0aGlzLmEpLkMoIk4zPFlrLkssWWsuVj4oWWsuSykiKX19ClAu
+S1AucHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcy5jLmEoYikK
+cy5RWzFdLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgdW5tb2RpZmlhYmxlIG1hcCIp
+KX19ClAuUG4ucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEucSgwLGIpfSwK
+WTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKdGhpcy5hLlk1KDAscy5jLmEoYikscy5R
+WzFdLmEoYykpfSwKeDQ6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS54NChhKX0sCks6ZnVuY3Rpb24o
+YSxiKXt0aGlzLmEuSygwLEguTGgodGhpcykuQygifigxLDIpIikuYShiKSl9LApnbDA6ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmdsMChzKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
+YQpyZXR1cm4gcy5nQShzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudyh0aGlzLmEpfSwKZ1B1OmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nUHUocyl9LAokaVowOjF9ClAuR2oucHJvdG90
+eXBlPXt9ClAubGYucHJvdG90eXBlPXsKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMp
+PT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKSE9PTB9LApGVjpmdW5jdGlv
+bihhLGIpe3ZhciBzCmZvcihzPUouSVQoSC5MaCh0aGlzKS5DKCJjWDxsZi5FPiIpLmEoYikpO3MuRigp
+Oyl0aGlzLmkoMCxzLmdsKCkpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gUC54KHRoaXMsInsiLCJ9Iil9
+LAprOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmdtKHRoaXMpCmlmKCFyLkYoKSlyZXR1cm4iIgpp
+ZihiPT09IiIpe3M9IiIKZG8gcys9SC5FaihyLmQpCndoaWxlKHIuRigpKX1lbHNle3M9SC5FaihyLmQp
+CmZvcig7ci5GKCk7KXM9cytiK0guRWooci5kKX1yZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c30s
+CmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguYksodGhpcyxiLEguTGgodGhpcykuQygibGYuRSIpKX0s
+CkU6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscD0iaW5kZXgiCkguY2IoYixwLHQuUykKUC5rMShiLHAp
+CmZvcihzPXRoaXMuZ20odGhpcykscj0wO3MuRigpOyl7cT1zLmQKaWYoYj09PXIpcmV0dXJuIHE7Kyty
+fXRocm93IEguYihQLkNmKGIsdGhpcyxwLG51bGwscikpfX0KUC5Wai5wcm90b3R5cGU9eyRpYlE6MSwk
+aWNYOjEsJGl4dToxfQpQLlh2LnByb3RvdHlwZT17JGliUToxLCRpY1g6MSwkaXh1OjF9ClAublkucHJv
+dG90eXBlPXt9ClAuV1kucHJvdG90eXBlPXt9ClAuUlUucHJvdG90eXBlPXt9ClAucFIucHJvdG90eXBl
+PXt9ClAudXcucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5iCmlmKHI9PW51
+bGwpcmV0dXJuIHRoaXMuYy5xKDAsYikKZWxzZSBpZih0eXBlb2YgYiE9InN0cmluZyIpcmV0dXJuIG51
+bGwKZWxzZXtzPXJbYl0KcmV0dXJuIHR5cGVvZiBzPT0idW5kZWZpbmVkIj90aGlzLmZiKGIpOnN9fSwK
+Z0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYj09bnVsbD90aGlzLmMuYTp0aGlzLkNmKCkubGVuZ3Ro
+fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpPT09MH0sCmd2YzpmdW5jdGlvbigp
+e2lmKHRoaXMuYj09bnVsbCl7dmFyIHM9dGhpcy5jCnJldHVybiBuZXcgSC5pNShzLEguTGgocykuQygi
+aTU8MT4iKSl9cmV0dXJuIG5ldyBQLmk4KHRoaXMpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIs
+cT10aGlzCmlmKHEuYj09bnVsbClxLmMuWTUoMCxiLGMpCmVsc2UgaWYocS54NChiKSl7cz1xLmIKc1ti
+XT1jCnI9cS5hCmlmKHI9PW51bGw/cyE9bnVsbDpyIT09cylyW2JdPW51bGx9ZWxzZSBxLlhLKCkuWTUo
+MCxiLGMpfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodGhpcy5iPT1udWxsKXJldHVybiB0aGlzLmMueDQoYSkK
+cmV0dXJuIE9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlzLmEsYSl9LApLOmZ1
+bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz10aGlzCnQuY0EuYShiKQppZihvLmI9PW51bGwpcmV0dXJu
+IG8uYy5LKDAsYikKcz1vLkNmKCkKZm9yKHI9MDtyPHMubGVuZ3RoOysrcil7cT1zW3JdCnA9by5iW3Fd
+CmlmKHR5cGVvZiBwPT0idW5kZWZpbmVkIil7cD1QLlFlKG8uYVtxXSkKby5iW3FdPXB9Yi4kMihxLHAp
+CmlmKHMhPT1vLmMpdGhyb3cgSC5iKFAuYTQobykpfX0sCkNmOmZ1bmN0aW9uKCl7dmFyIHM9dC5iTS5h
+KHRoaXMuYykKaWYocz09bnVsbClzPXRoaXMuYz1ILlFJKE9iamVjdC5rZXlzKHRoaXMuYSksdC5zKQpy
+ZXR1cm4gc30sClhLOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuPXRoaXMKaWYobi5iPT1udWxsKXJl
+dHVybiBuLmMKcz1QLkZsKHQuTix0LnopCnI9bi5DZigpCmZvcihxPTA7cD1yLmxlbmd0aCxxPHA7Kytx
+KXtvPXJbcV0Kcy5ZNSgwLG8sbi5xKDAsbykpfWlmKHA9PT0wKUMuTm0uaShyLCIiKQplbHNlIEMuTm0u
+c0EociwwKQpuLmE9bi5iPW51bGwKcmV0dXJuIG4uYz1zfSwKZmI6ZnVuY3Rpb24oYSl7dmFyIHMKaWYo
+IU9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlzLmEsYSkpcmV0dXJuIG51bGwK
+cz1QLlFlKHRoaXMuYVthXSkKcmV0dXJuIHRoaXMuYlthXT1zfX0KUC5pOC5wcm90b3R5cGU9ewpnQTpm
+dW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ0Eocyl9LApFOmZ1bmN0aW9uKGEsYil7dmFy
+IHM9dGhpcy5hCmlmKHMuYj09bnVsbClzPXMuZ3ZjKCkuRSgwLGIpCmVsc2V7cz1zLkNmKCkKaWYoYjww
+fHxiPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGIpCnM9c1tiXX1yZXR1cm4gc30sCmdtOmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMuYQppZihzLmI9PW51bGwpe3M9cy5ndmMoKQpzPXMuZ20ocyl9ZWxzZXtzPXMu
+Q2YoKQpzPW5ldyBKLm0xKHMscy5sZW5ndGgsSC50NihzKS5DKCJtMTwxPiIpKX1yZXR1cm4gc30sCnRn
+OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS54NChiKX19ClAueHIucHJvdG90eXBlPXsKJDA6ZnVu
+Y3Rpb24oKXt2YXIgcyxyCnRyeXtzPW5ldyBUZXh0RGVjb2RlcigidXRmLTgiLHtmYXRhbDp0cnVlfSkK
+cmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1yZXR1cm4gbnVsbH0sCiRTOjEyfQpQLk56LnByb3RvdHlw
 ZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscgp0cnl7cz1uZXcgVGV4dERlY29kZXIoInV0Zi04Iix7ZmF0
-YWw6dHJ1ZX0pCnJldHVybiBzfWNhdGNoKHIpe0guUnUocil9cmV0dXJuIG51bGx9LAokUzoxMn0KUC5O
-ei5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIKdHJ5e3M9bmV3IFRleHREZWNvZGVyKCJ1
-dGYtOCIse2ZhdGFsOmZhbHNlfSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1yZXR1cm4gbnVsbH0s
-CiRTOjEyfQpQLkNWLnByb3RvdHlwZT17CnlyOmZ1bmN0aW9uKGEwLGExLGEyKXt2YXIgcyxyLHEscCxv
-LG4sbSxsLGssaixpLGgsZyxmLGUsZCxjLGIsYT0iSW52YWxpZCBiYXNlNjQgZW5jb2RpbmcgbGVuZ3Ro
-ICIKYTI9UC5qQihhMSxhMixhMC5sZW5ndGgpCnM9JC5WNygpCmZvcihyPWExLHE9cixwPW51bGwsbz0t
-MSxuPS0xLG09MDtyPGEyO3I9bCl7bD1yKzEKaz1DLnhCLlcoYTAscikKaWYoaz09PTM3KXtqPWwrMgpp
-ZihqPD1hMil7aT1ILm9vKEMueEIuVyhhMCxsKSkKaD1ILm9vKEMueEIuVyhhMCxsKzEpKQpnPWkqMTYr
-aC0oaCYyNTYpCmlmKGc9PT0zNylnPS0xCmw9an1lbHNlIGc9LTF9ZWxzZSBnPWsKaWYoMDw9ZyYmZzw9
-MTI3KXtpZihnPDB8fGc+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsZykKZj1zW2ddCmlmKGY+PTApe2c9
-Qy54Qi5PKCJBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6
-MDEyMzQ1Njc4OSsvIixmKQppZihnPT09ayljb250aW51ZQprPWd9ZWxzZXtpZihmPT09LTEpe2lmKG88
-MCl7ZT1wPT1udWxsP251bGw6cC5hLmxlbmd0aAppZihlPT1udWxsKWU9MApvPWUrKHItcSkKbj1yfSsr
-bQppZihrPT09NjEpY29udGludWV9az1nfWlmKGYhPT0tMil7aWYocD09bnVsbCl7cD1uZXcgUC5Sbigi
-IikKZT1wfWVsc2UgZT1wCmUuYSs9Qy54Qi5OaihhMCxxLHIpCmUuYSs9SC5MdyhrKQpxPWwKY29udGlu
-dWV9fXRocm93IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBkYXRhIixhMCxyKSl9aWYocCE9bnVsbCl7
-ZT1wLmErPUMueEIuTmooYTAscSxhMikKZD1lLmxlbmd0aAppZihvPj0wKVAueE0oYTAsbixhMixvLG0s
-ZCkKZWxzZXtjPUMuam4uelkoZC0xLDQpKzEKaWYoYz09PTEpdGhyb3cgSC5iKFAucnIoYSxhMCxhMikp
-CmZvcig7Yzw0Oyl7ZSs9Ij0iCnAuYT1lOysrY319ZT1wLmEKcmV0dXJuIEMueEIuaTcoYTAsYTEsYTIs
-ZS5jaGFyQ29kZUF0KDApPT0wP2U6ZSl9Yj1hMi1hMQppZihvPj0wKVAueE0oYTAsbixhMixvLG0sYikK
-ZWxzZXtjPUMuam4uelkoYiw0KQppZihjPT09MSl0aHJvdyBILmIoUC5ycihhLGEwLGEyKSkKaWYoYz4x
-KWEwPUMueEIuaTcoYTAsYTIsYTIsYz09PTI/Ij09IjoiPSIpfXJldHVybiBhMH19ClAuVTgucHJvdG90
-eXBlPXt9ClAuVWsucHJvdG90eXBlPXt9ClAud0kucHJvdG90eXBlPXt9ClAuWmkucHJvdG90eXBlPXt9
-ClAuVWQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz1QLnAodGhpcy5hKQpyZXR1cm4odGhp
-cy5iIT1udWxsPyJDb252ZXJ0aW5nIG9iamVjdCB0byBhbiBlbmNvZGFibGUgb2JqZWN0IGZhaWxlZDoi
-OiJDb252ZXJ0aW5nIG9iamVjdCBkaWQgbm90IHJldHVybiBhbiBlbmNvZGFibGUgb2JqZWN0OiIpKyIg
-IitzfX0KUC5LOC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJDeWNsaWMgZXJyb3IgaW4g
-SlNPTiBzdHJpbmdpZnkifX0KUC5ieS5wcm90b3R5cGU9ewpwVzpmdW5jdGlvbihhLGIsYyl7dmFyIHMK
-dC5mVi5hKGMpCnM9UC5CUyhiLHRoaXMuZ0hlKCkuYSkKcmV0dXJuIHN9LApPQjpmdW5jdGlvbihhLGIp
-e3ZhciBzCnQuZEEuYShiKQpzPVAudVgoYSx0aGlzLmdaRSgpLmIsbnVsbCkKcmV0dXJuIHN9LApnWkU6
-ZnVuY3Rpb24oKXtyZXR1cm4gQy5uWH0sCmdIZTpmdW5jdGlvbigpe3JldHVybiBDLkEzfX0KUC5vai5w
-cm90b3R5cGU9e30KUC5NeC5wcm90b3R5cGU9e30KUC5TaC5wcm90b3R5cGU9ewpSVDpmdW5jdGlvbihh
-KXt2YXIgcyxyLHEscCxvLG4sbSxsPWEubGVuZ3RoCmZvcihzPUouclkoYSkscj10aGlzLmMscT0wLHA9
-MDtwPGw7KytwKXtvPXMuVyhhLHApCmlmKG8+OTIpe2lmKG8+PTU1Mjk2KXtuPW8mNjQ1MTIKaWYobj09
-PTU1Mjk2KXttPXArMQptPSEobTxsJiYoQy54Qi5XKGEsbSkmNjQ1MTIpPT09NTYzMjApfWVsc2UgbT0h
-MQppZighbSlpZihuPT09NTYzMjApe249cC0xCm49IShuPj0wJiYoQy54Qi5PKGEsbikmNjQ1MTIpPT09
-NTUyOTYpfWVsc2Ugbj0hMQplbHNlIG49ITAKaWYobil7aWYocD5xKXIuYSs9Qy54Qi5OaihhLHEscCkK
-cT1wKzEKci5hKz1ILkx3KDkyKQpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoMTAwKQpuPW8+Pj44JjE1
-CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbikKbj1vPj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3
-K24pCm49byYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pfX1jb250aW51ZX1pZihvPDMyKXtpZihw
-PnEpci5hKz1DLnhCLk5qKGEscSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnN3aXRjaChvKXtjYXNlIDg6
-ci5hKz1ILkx3KDk4KQpicmVhawpjYXNlIDk6ci5hKz1ILkx3KDExNikKYnJlYWsKY2FzZSAxMDpyLmEr
-PUguTHcoMTEwKQpicmVhawpjYXNlIDEyOnIuYSs9SC5MdygxMDIpCmJyZWFrCmNhc2UgMTM6ci5hKz1I
-Lkx3KDExNCkKYnJlYWsKZGVmYXVsdDpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoNDgpCnIuYSs9SC5M
-dyg0OCkKbj1vPj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pCm49byYxNQpyLmErPUguTHco
-bjwxMD80OCtuOjg3K24pCmJyZWFrfX1lbHNlIGlmKG89PT0zNHx8bz09PTkyKXtpZihwPnEpci5hKz1D
-LnhCLk5qKGEscSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnIuYSs9SC5MdyhvKX19aWYocT09PTApci5h
-Kz1ILkVqKGEpCmVsc2UgaWYocTxsKXIuYSs9cy5OaihhLHEsbCl9LApKbjpmdW5jdGlvbihhKXt2YXIg
-cyxyLHEscApmb3Iocz10aGlzLmEscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1zW3FdCmlmKGE9PW51
-bGw/cD09bnVsbDphPT09cCl0aHJvdyBILmIobmV3IFAuSzgoYSxudWxsKSl9Qy5ObS5pKHMsYSl9LApp
-VTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMKaWYoby50TShhKSlyZXR1cm4Kby5KbihhKQp0
-cnl7cz1vLmIuJDEoYSkKaWYoIW8udE0ocykpe3E9UC5HeShhLG51bGwsby5nVksoKSkKdGhyb3cgSC5i
-KHEpfXE9by5hCmlmKDA+PXEubGVuZ3RoKXJldHVybiBILk9IKHEsLTEpCnEucG9wKCl9Y2F0Y2gocCl7
-cj1ILlJ1KHApCnE9UC5HeShhLHIsby5nVksoKSkKdGhyb3cgSC5iKHEpfX0sCnRNOmZ1bmN0aW9uKGEp
-e3ZhciBzLHIscT10aGlzCmlmKHR5cGVvZiBhPT0ibnVtYmVyIil7aWYoIWlzRmluaXRlKGEpKXJldHVy
-biExCnEuYy5hKz1DLkNELncoYSkKcmV0dXJuITB9ZWxzZSBpZihhPT09ITApe3EuYy5hKz0idHJ1ZSIK
-cmV0dXJuITB9ZWxzZSBpZihhPT09ITEpe3EuYy5hKz0iZmFsc2UiCnJldHVybiEwfWVsc2UgaWYoYT09
-bnVsbCl7cS5jLmErPSJudWxsIgpyZXR1cm4hMH1lbHNlIGlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz1x
-LmMKcy5hKz0nIicKcS5SVChhKQpzLmErPSciJwpyZXR1cm4hMH1lbHNlIGlmKHQuai5iKGEpKXtxLkpu
-KGEpCnEubEsoYSkKcz1xLmEKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpy
-ZXR1cm4hMH1lbHNlIGlmKHQuZi5iKGEpKXtxLkpuKGEpCnI9cS5qdyhhKQpzPXEuYQppZigwPj1zLmxl
-bmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnJldHVybiByfWVsc2UgcmV0dXJuITF9LApsSzpm
-dW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcy5jCnEuYSs9IlsiCnM9Si5VNihhKQppZihzLmdvcihhKSl7
-dGhpcy5pVShzLnEoYSwwKSkKZm9yKHI9MTtyPHMuZ0EoYSk7KytyKXtxLmErPSIsIgp0aGlzLmlVKHMu
-cShhLHIpKX19cS5hKz0iXSJ9LApqdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9
-e30KaWYoYS5nbDAoYSkpe20uYy5hKz0ie30iCnJldHVybiEwfXM9YS5nQShhKSoyCnI9UC5POChzLG51
-bGwsITEsdC5XKQpxPWwuYT0wCmwuYj0hMAphLksoMCxuZXcgUC50aShsLHIpKQppZighbC5iKXJldHVy
-biExCnA9bS5jCnAuYSs9InsiCmZvcihvPSciJztxPHM7cSs9MixvPScsIicpe3AuYSs9bwptLlJUKEgu
-aChyW3FdKSkKcC5hKz0nIjonCm49cSsxCmlmKG4+PXMpcmV0dXJuIEguT0gocixuKQptLmlVKHJbbl0p
-fXAuYSs9In0iCnJldHVybiEwfX0KUC50aS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBz
-LHIKaWYodHlwZW9mIGEhPSJzdHJpbmciKXRoaXMuYS5iPSExCnM9dGhpcy5iCnI9dGhpcy5hCkMuTm0u
-WTUocyxyLmErKyxhKQpDLk5tLlk1KHMsci5hKyssYil9LAokUzoxMX0KUC50dS5wcm90b3R5cGU9ewpn
-Vks6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLmMuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c319
-ClAudTUucHJvdG90eXBlPXsKZ1pFOmZ1bmN0aW9uKCl7cmV0dXJuIEMuUWt9fQpQLkUzLnByb3RvdHlw
-ZT17CldKOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPVAuakIoMCxudWxsLGEubGVuZ3RoKSxvPXAtMApp
-ZihvPT09MClyZXR1cm4gbmV3IFVpbnQ4QXJyYXkoMCkKcz1vKjMKcj1uZXcgVWludDhBcnJheShzKQpx
-PW5ldyBQLlJ3KHIpCmlmKHEuR3goYSwwLHApIT09cCl7Si5hNihhLHAtMSkKcS5STygpfXJldHVybiBu
-ZXcgVWludDhBcnJheShyLnN1YmFycmF5KDAsSC5yTSgwLHEuYixzKSkpfX0KUC5Sdy5wcm90b3R5cGU9
-ewpSTzpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLmMscT1zLmIscD1zLmI9cSsxLG89ci5sZW5ndGgK
-aWYocT49bylyZXR1cm4gSC5PSChyLHEpCnJbcV09MjM5CnE9cy5iPXArMQppZihwPj1vKXJldHVybiBI
-Lk9IKHIscCkKcltwXT0xOTEKcy5iPXErMQppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT0xODl9
-LApPNjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj10aGlzCmlmKChiJjY0NTEyKT09PTU2MzIw
-KXtzPTY1NTM2KygoYSYxMDIzKTw8MTApfGImMTAyMwpyPW4uYwpxPW4uYgpwPW4uYj1xKzEKbz1yLmxl
-bmd0aAppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT1zPj4+MTh8MjQwCnE9bi5iPXArMQppZihw
-Pj1vKXJldHVybiBILk9IKHIscCkKcltwXT1zPj4+MTImNjN8MTI4CnA9bi5iPXErMQppZihxPj1vKXJl
-dHVybiBILk9IKHIscSkKcltxXT1zPj4+NiY2M3wxMjgKbi5iPXArMQppZihwPj1vKXJldHVybiBILk9I
-KHIscCkKcltwXT1zJjYzfDEyOApyZXR1cm4hMH1lbHNle24uUk8oKQpyZXR1cm4hMX19LApHeDpmdW5j
-dGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzCmlmKGIhPT1jJiYoQy54Qi5PKGEsYy0x
-KSY2NDUxMik9PT01NTI5NiktLWMKZm9yKHM9bC5jLHI9cy5sZW5ndGgscT1iO3E8YzsrK3Epe3A9Qy54
-Qi5XKGEscSkKaWYocDw9MTI3KXtvPWwuYgppZihvPj1yKWJyZWFrCmwuYj1vKzEKc1tvXT1wfWVsc2V7
-bz1wJjY0NTEyCmlmKG89PT01NTI5Nil7aWYobC5iKzQ+cilicmVhawpuPXErMQppZihsLk82KHAsQy54
-Qi5XKGEsbikpKXE9bn1lbHNlIGlmKG89PT01NjMyMCl7aWYobC5iKzM+cilicmVhawpsLlJPKCl9ZWxz
-ZSBpZihwPD0yMDQ3KXtvPWwuYgptPW8rMQppZihtPj1yKWJyZWFrCmwuYj1tCmlmKG8+PXIpcmV0dXJu
-IEguT0gocyxvKQpzW29dPXA+Pj42fDE5MgpsLmI9bSsxCnNbbV09cCY2M3wxMjh9ZWxzZXtvPWwuYgpp
-ZihvKzI+PXIpYnJlYWsKbT1sLmI9bysxCmlmKG8+PXIpcmV0dXJuIEguT0gocyxvKQpzW29dPXA+Pj4x
-MnwyMjQKbz1sLmI9bSsxCmlmKG0+PXIpcmV0dXJuIEguT0gocyxtKQpzW21dPXA+Pj42JjYzfDEyOAps
-LmI9bysxCmlmKG8+PXIpcmV0dXJuIEguT0gocyxvKQpzW29dPXAmNjN8MTI4fX19cmV0dXJuIHF9fQpQ
-LkdZLnByb3RvdHlwZT17CldKOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdC5MLmEoYSkKcz10aGlzLmEKcj1Q
-Lmt5KHMsYSwwLG51bGwpCmlmKHIhPW51bGwpcmV0dXJuIHIKcmV0dXJuIG5ldyBQLmJ6KHMpLk5lKGEs
-MCxudWxsLCEwKX19ClAuYnoucHJvdG90eXBlPXsKTmU6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixx
-LHAsbyxuPXRoaXMKdC5MLmEoYSkKcz1QLmpCKGIsYyxKLkhtKGEpKQppZihiPT09cylyZXR1cm4iIgpy
-PVAuankoYSxiLHMpCnE9bi5oTyhyLDAscy1iLCEwKQpwPW4uYgppZigocCYxKSE9PTApe289UC5qNChw
-KQpuLmI9MAp0aHJvdyBILmIoUC5ycihvLGEsYituLmMpKX1yZXR1cm4gcX0sCmhPOmZ1bmN0aW9uKGEs
-YixjLGQpe3ZhciBzLHIscT10aGlzCmlmKGMtYj4xMDAwKXtzPUMuam4uQlUoYitjLDIpCnI9cS5oTyhh
-LGIscywhMSkKaWYoKHEuYiYxKSE9PTApcmV0dXJuIHIKcmV0dXJuIHIrcS5oTyhhLHMsYyxkKX1yZXR1
-cm4gcS5FaChhLGIsYyxkKX0sCkVoOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG8sbixtLGws
-az10aGlzLGo9NjU1MzMsaT1rLmIsaD1rLmMsZz1uZXcgUC5SbigiIiksZj1iKzEsZT1hLmxlbmd0aApp
-ZihiPDB8fGI+PWUpcmV0dXJuIEguT0goYSxiKQpzPWFbYl0KJGxhYmVsMCQwOmZvcihyPWsuYTshMDsp
-e2Zvcig7ITA7Zj1vKXtxPUMueEIuVygiQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
+YWw6ZmFsc2V9KQpyZXR1cm4gc31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxsfSwKJFM6MTJ9ClAu
+Q1YucHJvdG90eXBlPXsKeXI6ZnVuY3Rpb24oYTAsYTEsYTIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxq
+LGksaCxnLGYsZSxkLGMsYixhPSJJbnZhbGlkIGJhc2U2NCBlbmNvZGluZyBsZW5ndGggIgphMj1QLmpC
+KGExLGEyLGEwLmxlbmd0aCkKcz0kLlY3KCkKZm9yKHI9YTEscT1yLHA9bnVsbCxvPS0xLG49LTEsbT0w
+O3I8YTI7cj1sKXtsPXIrMQprPUMueEIuVyhhMCxyKQppZihrPT09Mzcpe2o9bCsyCmlmKGo8PWEyKXtp
+PUgub28oQy54Qi5XKGEwLGwpKQpoPUgub28oQy54Qi5XKGEwLGwrMSkpCmc9aSoxNitoLShoJjI1NikK
+aWYoZz09PTM3KWc9LTEKbD1qfWVsc2UgZz0tMX1lbHNlIGc9awppZigwPD1nJiZnPD0xMjcpe2lmKGc8
+MHx8Zz49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxnKQpmPXNbZ10KaWYoZj49MCl7Zz1DLnhCLk8oIkFC
+Q0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5
+Ky8iLGYpCmlmKGc9PT1rKWNvbnRpbnVlCms9Z31lbHNle2lmKGY9PT0tMSl7aWYobzwwKXtlPXA9PW51
+bGw/bnVsbDpwLmEubGVuZ3RoCmlmKGU9PW51bGwpZT0wCm89ZSsoci1xKQpuPXJ9KyttCmlmKGs9PT02
+MSljb250aW51ZX1rPWd9aWYoZiE9PS0yKXtpZihwPT1udWxsKXtwPW5ldyBQLk0oIiIpCmU9cH1lbHNl
+IGU9cApkPWUuYSs9Qy54Qi5OaihhMCxxLHIpCmUuYT1kK0guTHcoaykKcT1sCmNvbnRpbnVlfX10aHJv
+dyBILmIoUC5ycigiSW52YWxpZCBiYXNlNjQgZGF0YSIsYTAscikpfWlmKHAhPW51bGwpe2U9cC5hKz1D
+LnhCLk5qKGEwLHEsYTIpCmQ9ZS5sZW5ndGgKaWYobz49MClQLnhNKGEwLG4sYTIsbyxtLGQpCmVsc2V7
+Yz1DLmpuLnpZKGQtMSw0KSsxCmlmKGM9PT0xKXRocm93IEguYihQLnJyKGEsYTAsYTIpKQpmb3IoO2M8
+NDspe2UrPSI9IgpwLmE9ZTsrK2N9fWU9cC5hCnJldHVybiBDLnhCLmk3KGEwLGExLGEyLGUuY2hhckNv
+ZGVBdCgwKT09MD9lOmUpfWI9YTItYTEKaWYobz49MClQLnhNKGEwLG4sYTIsbyxtLGIpCmVsc2V7Yz1D
+LmpuLnpZKGIsNCkKaWYoYz09PTEpdGhyb3cgSC5iKFAucnIoYSxhMCxhMikpCmlmKGM+MSlhMD1DLnhC
+Lmk3KGEwLGEyLGEyLGM9PT0yPyI9PSI6Ij0iKX1yZXR1cm4gYTB9fQpQLlU4LnByb3RvdHlwZT17fQpQ
+LlVrLnByb3RvdHlwZT17fQpQLndJLnByb3RvdHlwZT17fQpQLlppLnByb3RvdHlwZT17fQpQLlVkLnBy
+b3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9UC5obCh0aGlzLmEpCnJldHVybih0aGlzLmIhPW51
+bGw/IkNvbnZlcnRpbmcgb2JqZWN0IHRvIGFuIGVuY29kYWJsZSBvYmplY3QgZmFpbGVkOiI6IkNvbnZl
+cnRpbmcgb2JqZWN0IGRpZCBub3QgcmV0dXJuIGFuIGVuY29kYWJsZSBvYmplY3Q6IikrIiAiK3N9fQpQ
+Lks4LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkN5Y2xpYyBlcnJvciBpbiBKU09OIHN0
+cmluZ2lmeSJ9fQpQLmJ5LnByb3RvdHlwZT17CnBXOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwp0LmZWLmEo
+YykKcz1QLkJTKGIsdGhpcy5nSGUoKS5hKQpyZXR1cm4gc30sCk9COmZ1bmN0aW9uKGEsYil7dmFyIHMK
+dC5kQS5hKGIpCnM9UC51WChhLHRoaXMuZ1pFKCkuYixudWxsKQpyZXR1cm4gc30sCmdaRTpmdW5jdGlv
+bigpe3JldHVybiBDLm5YfSwKZ0hlOmZ1bmN0aW9uKCl7cmV0dXJuIEMuQTN9fQpQLm9qLnByb3RvdHlw
+ZT17fQpQLk14LnByb3RvdHlwZT17fQpQLlNoLnByb3RvdHlwZT17ClJUOmZ1bmN0aW9uKGEpe3ZhciBz
+LHIscSxwLG8sbixtLGw9YS5sZW5ndGgKZm9yKHM9Si5yWShhKSxyPXRoaXMuYyxxPTAscD0wO3A8bDsr
+K3Ape289cy5XKGEscCkKaWYobz45Mil7aWYobz49NTUyOTYpe249byY2NDUxMgppZihuPT09NTUyOTYp
+e209cCsxCm09IShtPGwmJihDLnhCLlcoYSxtKSY2NDUxMik9PT01NjMyMCl9ZWxzZSBtPSExCmlmKCFt
+KWlmKG49PT01NjMyMCl7bj1wLTEKbj0hKG4+PTAmJihDLnhCLk8oYSxuKSY2NDUxMik9PT01NTI5Nil9
+ZWxzZSBuPSExCmVsc2Ugbj0hMAppZihuKXtpZihwPnEpci5hKz1DLnhCLk5qKGEscSxwKQpxPXArMQpu
+PXIuYSs9SC5Mdyg5MikKbis9SC5MdygxMTcpCnIuYT1uCm4rPUguTHcoMTAwKQpyLmE9bgptPW8+Pj44
+JjE1Cm4rPUguTHcobTwxMD80OCttOjg3K20pCnIuYT1uCm09bz4+PjQmMTUKbis9SC5MdyhtPDEwPzQ4
+K206ODcrbSkKci5hPW4KbT1vJjE1CnIuYT1uK0guTHcobTwxMD80OCttOjg3K20pfX1jb250aW51ZX1p
+ZihvPDMyKXtpZihwPnEpci5hKz1DLnhCLk5qKGEscSxwKQpxPXArMQpuPXIuYSs9SC5Mdyg5MikKc3dp
+dGNoKG8pe2Nhc2UgODpyLmE9bitILkx3KDk4KQpicmVhawpjYXNlIDk6ci5hPW4rSC5MdygxMTYpCmJy
+ZWFrCmNhc2UgMTA6ci5hPW4rSC5MdygxMTApCmJyZWFrCmNhc2UgMTI6ci5hPW4rSC5MdygxMDIpCmJy
+ZWFrCmNhc2UgMTM6ci5hPW4rSC5MdygxMTQpCmJyZWFrCmRlZmF1bHQ6bis9SC5MdygxMTcpCnIuYT1u
+Cm4rPUguTHcoNDgpCnIuYT1uCm4rPUguTHcoNDgpCnIuYT1uCm09bz4+PjQmMTUKbis9SC5MdyhtPDEw
+PzQ4K206ODcrbSkKci5hPW4KbT1vJjE1CnIuYT1uK0guTHcobTwxMD80OCttOjg3K20pCmJyZWFrfX1l
+bHNlIGlmKG89PT0zNHx8bz09PTkyKXtpZihwPnEpci5hKz1DLnhCLk5qKGEscSxwKQpxPXArMQpuPXIu
+YSs9SC5Mdyg5MikKci5hPW4rSC5MdyhvKX19aWYocT09PTApci5hKz1ILkVqKGEpCmVsc2UgaWYocTxs
+KXIuYSs9cy5OaihhLHEsbCl9LApKbjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscApmb3Iocz10aGlzLmEs
+cj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1zW3FdCmlmKGE9PW51bGw/cD09bnVsbDphPT09cCl0aHJv
+dyBILmIobmV3IFAuSzgoYSxudWxsKSl9Qy5ObS5pKHMsYSl9LAppVTpmdW5jdGlvbihhKXt2YXIgcyxy
+LHEscCxvPXRoaXMKaWYoby50TShhKSlyZXR1cm4Kby5KbihhKQp0cnl7cz1vLmIuJDEoYSkKaWYoIW8u
+dE0ocykpe3E9UC5HeShhLG51bGwsby5nVksoKSkKdGhyb3cgSC5iKHEpfXE9by5hCmlmKDA+PXEubGVu
+Z3RoKXJldHVybiBILk9IKHEsLTEpCnEucG9wKCl9Y2F0Y2gocCl7cj1ILlJ1KHApCnE9UC5HeShhLHIs
+by5nVksoKSkKdGhyb3cgSC5iKHEpfX0sCnRNOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzCmlmKHR5
+cGVvZiBhPT0ibnVtYmVyIil7aWYoIWlzRmluaXRlKGEpKXJldHVybiExCnEuYy5hKz1DLkNELncoYSkK
+cmV0dXJuITB9ZWxzZSBpZihhPT09ITApe3EuYy5hKz0idHJ1ZSIKcmV0dXJuITB9ZWxzZSBpZihhPT09
+ITEpe3EuYy5hKz0iZmFsc2UiCnJldHVybiEwfWVsc2UgaWYoYT09bnVsbCl7cS5jLmErPSJudWxsIgpy
+ZXR1cm4hMH1lbHNlIGlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz1xLmMKcy5hKz0nIicKcS5SVChhKQpz
+LmErPSciJwpyZXR1cm4hMH1lbHNlIGlmKHQuai5iKGEpKXtxLkpuKGEpCnEubEsoYSkKcz1xLmEKaWYo
+MD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpyZXR1cm4hMH1lbHNlIGlmKHQuZi5i
+KGEpKXtxLkpuKGEpCnI9cS5qdyhhKQpzPXEuYQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0x
+KQpzLnBvcCgpCnJldHVybiByfWVsc2UgcmV0dXJuITF9LApsSzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9
+dGhpcy5jCnEuYSs9IlsiCnM9Si5VNihhKQppZihzLmdvcihhKSl7dGhpcy5pVShzLnEoYSwwKSkKZm9y
+KHI9MTtyPHMuZ0EoYSk7KytyKXtxLmErPSIsIgp0aGlzLmlVKHMucShhLHIpKX19cS5hKz0iXSJ9LApq
+dzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9e30KaWYoYS5nbDAoYSkpe20uYy5h
+Kz0ie30iCnJldHVybiEwfXM9YS5nQShhKSoyCnI9UC5POChzLG51bGwsITEsdC5XKQpxPWwuYT0wCmwu
+Yj0hMAphLksoMCxuZXcgUC50aShsLHIpKQppZighbC5iKXJldHVybiExCnA9bS5jCnAuYSs9InsiCmZv
+cihvPSciJztxPHM7cSs9MixvPScsIicpe3AuYSs9bwptLlJUKEguaChyW3FdKSkKcC5hKz0nIjonCm49
+cSsxCmlmKG4+PXMpcmV0dXJuIEguT0gocixuKQptLmlVKHJbbl0pfXAuYSs9In0iCnJldHVybiEwfX0K
+UC50aS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYodHlwZW9mIGEhPSJzdHJp
+bmciKXRoaXMuYS5iPSExCnM9dGhpcy5iCnI9dGhpcy5hCkMuTm0uWTUocyxyLmErKyxhKQpDLk5tLlk1
+KHMsci5hKyssYil9LAokUzoxMX0KUC50dS5wcm90b3R5cGU9ewpnVks6ZnVuY3Rpb24oKXt2YXIgcz10
+aGlzLmMuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c319ClAudTUucHJvdG90eXBlPXsKZ1pF
+OmZ1bmN0aW9uKCl7cmV0dXJuIEMuUWt9fQpQLkUzLnByb3RvdHlwZT17CldKOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHIscSxwPVAuakIoMCxudWxsLGEubGVuZ3RoKSxvPXAtMAppZihvPT09MClyZXR1cm4gbmV3IFVp
+bnQ4QXJyYXkoMCkKcz1vKjMKcj1uZXcgVWludDhBcnJheShzKQpxPW5ldyBQLlJ3KHIpCmlmKHEuR3go
+YSwwLHApIT09cCl7Si5hNihhLHAtMSkKcS5STygpfXJldHVybiBuZXcgVWludDhBcnJheShyLnN1YmFy
+cmF5KDAsSC5yTSgwLHEuYixzKSkpfX0KUC5Sdy5wcm90b3R5cGU9ewpSTzpmdW5jdGlvbigpe3ZhciBz
+PXRoaXMscj1zLmMscT1zLmIscD1zLmI9cSsxLG89ci5sZW5ndGgKaWYocT49bylyZXR1cm4gSC5PSChy
+LHEpCnJbcV09MjM5CnE9cy5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkKcltwXT0xOTEKcy5i
+PXErMQppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT0xODl9LApPNjpmdW5jdGlvbihhLGIpe3Zh
+ciBzLHIscSxwLG8sbj10aGlzCmlmKChiJjY0NTEyKT09PTU2MzIwKXtzPTY1NTM2KygoYSYxMDIzKTw8
+MTApfGImMTAyMwpyPW4uYwpxPW4uYgpwPW4uYj1xKzEKbz1yLmxlbmd0aAppZihxPj1vKXJldHVybiBI
+Lk9IKHIscSkKcltxXT1zPj4+MTh8MjQwCnE9bi5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkK
+cltwXT1zPj4+MTImNjN8MTI4CnA9bi5iPXErMQppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT1z
+Pj4+NiY2M3wxMjgKbi5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkKcltwXT1zJjYzfDEyOApy
+ZXR1cm4hMH1lbHNle24uUk8oKQpyZXR1cm4hMX19LApHeDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixx
+LHAsbyxuLG0sbD10aGlzCmlmKGIhPT1jJiYoQy54Qi5PKGEsYy0xKSY2NDUxMik9PT01NTI5NiktLWMK
+Zm9yKHM9bC5jLHI9cy5sZW5ndGgscT1iO3E8YzsrK3Epe3A9Qy54Qi5XKGEscSkKaWYocDw9MTI3KXtv
+PWwuYgppZihvPj1yKWJyZWFrCmwuYj1vKzEKc1tvXT1wfWVsc2V7bz1wJjY0NTEyCmlmKG89PT01NTI5
+Nil7aWYobC5iKzQ+cilicmVhawpuPXErMQppZihsLk82KHAsQy54Qi5XKGEsbikpKXE9bn1lbHNlIGlm
+KG89PT01NjMyMCl7aWYobC5iKzM+cilicmVhawpsLlJPKCl9ZWxzZSBpZihwPD0yMDQ3KXtvPWwuYgpt
+PW8rMQppZihtPj1yKWJyZWFrCmwuYj1tCmlmKG8+PXIpcmV0dXJuIEguT0gocyxvKQpzW29dPXA+Pj42
+fDE5MgpsLmI9bSsxCnNbbV09cCY2M3wxMjh9ZWxzZXtvPWwuYgppZihvKzI+PXIpYnJlYWsKbT1sLmI9
+bysxCmlmKG8+PXIpcmV0dXJuIEguT0gocyxvKQpzW29dPXA+Pj4xMnwyMjQKbz1sLmI9bSsxCmlmKG0+
+PXIpcmV0dXJuIEguT0gocyxtKQpzW21dPXA+Pj42JjYzfDEyOApsLmI9bysxCmlmKG8+PXIpcmV0dXJu
+IEguT0gocyxvKQpzW29dPXAmNjN8MTI4fX19cmV0dXJuIHF9fQpQLkdZLnByb3RvdHlwZT17CldKOmZ1
+bmN0aW9uKGEpe3ZhciBzLHIKdC5MLmEoYSkKcz10aGlzLmEKcj1QLmt5KHMsYSwwLG51bGwpCmlmKHIh
+PW51bGwpcmV0dXJuIHIKcmV0dXJuIG5ldyBQLmJ6KHMpLk5lKGEsMCxudWxsLCEwKX19ClAuYnoucHJv
+dG90eXBlPXsKTmU6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuPXRoaXMKdC5MLmEoYSkK
+cz1QLmpCKGIsYyxKLkhtKGEpKQppZihiPT09cylyZXR1cm4iIgpyPVAuankoYSxiLHMpCnE9bi5oTyhy
+LDAscy1iLCEwKQpwPW4uYgppZigocCYxKSE9PTApe289UC5qNChwKQpuLmI9MAp0aHJvdyBILmIoUC5y
+cihvLGEsYituLmMpKX1yZXR1cm4gcX0sCmhPOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscT10aGlz
+CmlmKGMtYj4xMDAwKXtzPUMuam4uQlUoYitjLDIpCnI9cS5oTyhhLGIscywhMSkKaWYoKHEuYiYxKSE9
+PTApcmV0dXJuIHIKcmV0dXJuIHIrcS5oTyhhLHMsYyxkKX1yZXR1cm4gcS5FaChhLGIsYyxkKX0sCkVo
+OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG8sbixtLGwsaz10aGlzLGo9NjU1MzMsaT1rLmIs
+aD1rLmMsZz1uZXcgUC5NKCIiKSxmPWIrMSxlPWEubGVuZ3RoCmlmKGI8MHx8Yj49ZSlyZXR1cm4gSC5P
+SChhLGIpCnM9YVtiXQokbGFiZWwwJDA6Zm9yKHI9ay5hOyEwOyl7Zm9yKDshMDtmPW8pe3E9Qy54Qi5X
+KCJBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
 QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
-QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFGRkZGRkZGRkZGRkZGRkZGR0dHR0dHR0dHR0dH
-R0dHR0hISEhISEhISEhISEhISEhISEhISEhISEhISElISEhKRUVCQkJCQkJCQkJCQkJCQkJCQkJCQkJC
-QkJCQkJCQkJLQ0NDQ0NDQ0NDQ0NDRENMT05OTk1FRUVFRUVFRUVFRSIscykmMzEKaD1pPD0zMj9zJjYx
-Njk0Pj4+cToocyY2M3xoPDw2KT4+PjAKaT1DLnhCLlcoIiBceDAwMDpYRUNDQ0NDTjpsRGIgXHgwMDA6
-WEVDQ0NDQ052bERiIFx4MDAwOlhFQ0NDQ0NOOmxEYiBBQUFBQVx4MDBceDAwXHgwMFx4MDBceDAwQUFB
-QUEwMDAwMEFBQUFBOjo6OjpBQUFBQUdHMDAwQUFBQUEwMEtLS0FBQUFBRzo6OjpBQUFBQTpJSUlJQUFB
-QUEwMDBceDgwMEFBQUFBXHgwMFx4MDBceDAwXHgwMCBBQUFBQSIsaStxKQppZihpPT09MCl7Zy5hKz1I
-Lkx3KGgpCmlmKGY9PT1jKWJyZWFrICRsYWJlbDAkMApicmVha31lbHNlIGlmKChpJjEpIT09MCl7aWYo
-cilzd2l0Y2goaSl7Y2FzZSA2OTpjYXNlIDY3OmcuYSs9SC5MdyhqKQpicmVhawpjYXNlIDY1OmcuYSs9
-SC5MdyhqKTstLWYKYnJlYWsKZGVmYXVsdDpwPWcuYSs9SC5MdyhqKQpnLmE9cCtILkx3KGopCmJyZWFr
-fWVsc2V7ay5iPWkKay5jPWYtMQpyZXR1cm4iIn1pPTB9aWYoZj09PWMpYnJlYWsgJGxhYmVsMCQwCm89
-ZisxCmlmKGY8MHx8Zj49ZSlyZXR1cm4gSC5PSChhLGYpCnM9YVtmXX1vPWYrMQppZihmPDB8fGY+PWUp
-cmV0dXJuIEguT0goYSxmKQpzPWFbZl0KaWYoczwxMjgpe3doaWxlKCEwKXtpZighKG88Yykpe249Ywpi
-cmVha31tPW8rMQppZihvPDB8fG8+PWUpcmV0dXJuIEguT0goYSxvKQpzPWFbb10KaWYocz49MTI4KXtu
-PW0tMQpvPW0KYnJlYWt9bz1tfWlmKG4tZjwyMClmb3IobD1mO2w8bjsrK2wpe2lmKGw+PWUpcmV0dXJu
-IEguT0goYSxsKQpnLmErPUguTHcoYVtsXSl9ZWxzZSBnLmErPVAuSE0oYSxmLG4pCmlmKG49PT1jKWJy
-ZWFrICRsYWJlbDAkMApmPW99ZWxzZSBmPW99aWYoZCYmaT4zMilpZihyKWcuYSs9SC5MdyhqKQplbHNl
-e2suYj03NwprLmM9YwpyZXR1cm4iIn1rLmI9aQprLmM9aAplPWcuYQpyZXR1cm4gZS5jaGFyQ29kZUF0
-KDApPT0wP2U6ZX19ClAuV0YucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKdC5m
-by5hKGEpCnM9dGhpcy5iCnI9dGhpcy5hCnMuYSs9ci5hCnE9cy5hKz1ILkVqKGEuYSkKcy5hPXErIjog
-IgpzLmErPVAucChiKQpyLmE9IiwgIn0sCiRTOjQwfQpQLmlQLnByb3RvdHlwZT17CkROOmZ1bmN0aW9u
-KGEsYil7aWYoYj09bnVsbClyZXR1cm4hMQpyZXR1cm4gYiBpbnN0YW5jZW9mIFAuaVAmJnRoaXMuYT09
-PWIuYSYmITB9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybihzXkMuam4ud0cocywz
-MCkpJjEwNzM3NDE4MjN9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1QLkdxKEgudEoocykpLHE9
-UC5oMChILk5TKHMpKSxwPVAuaDAoSC5qQShzKSksbz1QLmgwKEguSVgocykpLG49UC5oMChILmNoKHMp
-KSxtPVAuaDAoSC5KZChzKSksbD1QLlZ4KEgubzEocykpLGs9cisiLSIrcSsiLSIrcCsiICIrbysiOiIr
-bisiOiIrbSsiLiIrbApyZXR1cm4ga319ClAuWFMucHJvdG90eXBlPXsKZ0lJOmZ1bmN0aW9uKCl7cmV0
-dXJuIEgudHModGhpcy4kdGhyb3duSnNFcnJvcil9fQpQLkM2LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
-YSl7dmFyIHM9dGhpcy5hCmlmKHMhPW51bGwpcmV0dXJuIkFzc2VydGlvbiBmYWlsZWQ6ICIrUC5wKHMp
-CnJldHVybiJBc3NlcnRpb24gZmFpbGVkIn19ClAuRXoucHJvdG90eXBlPXt9ClAuRi5wcm90b3R5cGU9
-ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJUaHJvdyBvZiBudWxsLiJ9fQpQLnUucHJvdG90eXBlPXsKZ1o6
-ZnVuY3Rpb24oKXtyZXR1cm4iSW52YWxpZCBhcmd1bWVudCIrKCF0aGlzLmE/IihzKSI6IiIpfSwKZ3U6
-ZnVuY3Rpb24oKXtyZXR1cm4iIn0sCnc6ZnVuY3Rpb24oYSl7dmFyIHMscixxPXRoaXMscD1xLmMsbz1w
-PT1udWxsPyIiOiIgKCIrcCsiKSIsbj1xLmQsbT1uPT1udWxsPyIiOiI6ICIrSC5FaihuKSxsPXEuZ1oo
-KStvK20KaWYoIXEuYSlyZXR1cm4gbApzPXEuZ3UoKQpyPVAucChxLmIpCnJldHVybiBsK3MrIjogIity
-fX0KUC5iSi5wcm90b3R5cGU9ewpnWjpmdW5jdGlvbigpe3JldHVybiJSYW5nZUVycm9yIn0sCmd1OmZ1
-bmN0aW9uKCl7dmFyIHMscj10aGlzLmUscT10aGlzLmYKaWYocj09bnVsbClzPXEhPW51bGw/IjogTm90
-IGxlc3MgdGhhbiBvciBlcXVhbCB0byAiK0guRWoocSk6IiIKZWxzZSBpZihxPT1udWxsKXM9IjogTm90
-IGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAiK0guRWoocikKZWxzZSBpZihxPnIpcz0iOiBOb3QgaW4g
-aW5jbHVzaXZlIHJhbmdlICIrSC5FaihyKSsiLi4iK0guRWoocSkKZWxzZSBzPXE8cj8iOiBWYWxpZCB2
-YWx1ZSByYW5nZSBpcyBlbXB0eSI6IjogT25seSB2YWxpZCB2YWx1ZSBpcyAiK0guRWoocikKcmV0dXJu
-IHN9fQpQLmVZLnByb3RvdHlwZT17CmdaOmZ1bmN0aW9uKCl7cmV0dXJuIlJhbmdlRXJyb3IifSwKZ3U6
-ZnVuY3Rpb24oKXt2YXIgcyxyPUgudVAodGhpcy5iKQppZih0eXBlb2YgciE9PSJudW1iZXIiKXJldHVy
-biByLkooKQppZihyPDApcmV0dXJuIjogaW5kZXggbXVzdCBub3QgYmUgbmVnYXRpdmUiCnM9dGhpcy5m
-CmlmKHM9PT0wKXJldHVybiI6IG5vIGluZGljZXMgYXJlIHZhbGlkIgpyZXR1cm4iOiBpbmRleCBzaG91
-bGQgYmUgbGVzcyB0aGFuICIrSC5FaihzKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmZ9fQpQ
-Lm1wLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRoaXMsaj17
-fSxpPW5ldyBQLlJuKCIiKQpqLmE9IiIKcz1rLmMKZm9yKHI9cy5sZW5ndGgscT0wLHA9IiIsbz0iIjtx
-PHI7KytxLG89IiwgIil7bj1zW3FdCmkuYT1wK28KcD1pLmErPVAucChuKQpqLmE9IiwgIn1rLmQuSygw
-LG5ldyBQLldGKGosaSkpCm09UC5wKGsuYSkKbD1pLncoMCkKcj0iTm9TdWNoTWV0aG9kRXJyb3I6IG1l
-dGhvZCBub3QgZm91bmQ6ICciK0guRWooay5iLmEpKyInXG5SZWNlaXZlcjogIittKyJcbkFyZ3VtZW50
-czogWyIrbCsiXSIKcmV0dXJuIHJ9fQpQLnViLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJu
-IlVuc3VwcG9ydGVkIG9wZXJhdGlvbjogIit0aGlzLmF9fQpQLmRzLnByb3RvdHlwZT17Cnc6ZnVuY3Rp
-b24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzIT1udWxsPyJVbmltcGxlbWVudGVkRXJyb3I6ICIrczoi
-VW5pbXBsZW1lbnRlZEVycm9yIn19ClAubGoucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4i
-QmFkIHN0YXRlOiAiK3RoaXMuYX19ClAuVVYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10
-aGlzLmEKaWYocz09bnVsbClyZXR1cm4iQ29uY3VycmVudCBtb2RpZmljYXRpb24gZHVyaW5nIGl0ZXJh
-dGlvbi4iCnJldHVybiJDb25jdXJyZW50IG1vZGlmaWNhdGlvbiBkdXJpbmcgaXRlcmF0aW9uOiAiK1Au
-cChzKSsiLiJ9fQpQLms1LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk91dCBvZiBNZW1v
-cnkifSwKZ0lJOmZ1bmN0aW9uKCl7cmV0dXJuIG51bGx9LAokaVhTOjF9ClAuS1kucHJvdG90eXBlPXsK
-dzpmdW5jdGlvbihhKXtyZXR1cm4iU3RhY2sgT3ZlcmZsb3cifSwKZ0lJOmZ1bmN0aW9uKCl7cmV0dXJu
-IG51bGx9LAokaVhTOjF9ClAuYy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpy
-ZXR1cm4gcz09bnVsbD8iUmVhZGluZyBzdGF0aWMgdmFyaWFibGUgZHVyaW5nIGl0cyBpbml0aWFsaXph
-dGlvbiI6IlJlYWRpbmcgc3RhdGljIHZhcmlhYmxlICciK3MrIicgZHVyaW5nIGl0cyBpbml0aWFsaXph
-dGlvbiJ9fQpQLkNELnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkV4Y2VwdGlvbjogIit0
-aGlzLmF9LAokaVJ6OjF9ClAuYUUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxv
-LG4sbSxsLGssaixpLGgsZz10aGlzLmEsZj1nIT1udWxsJiYiIiE9PWc/IkZvcm1hdEV4Y2VwdGlvbjog
-IitILkVqKGcpOiJGb3JtYXRFeGNlcHRpb24iLGU9dGhpcy5jLGQ9dGhpcy5iCmlmKHR5cGVvZiBkPT0i
-c3RyaW5nIil7aWYoZSE9bnVsbClzPWU8MHx8ZT5kLmxlbmd0aAplbHNlIHM9ITEKaWYocyllPW51bGwK
-aWYoZT09bnVsbCl7aWYoZC5sZW5ndGg+NzgpZD1DLnhCLk5qKGQsMCw3NSkrIi4uLiIKcmV0dXJuIGYr
-IlxuIitkfWZvcihyPTEscT0wLHA9ITEsbz0wO288ZTsrK28pe249Qy54Qi5XKGQsbykKaWYobj09PTEw
-KXtpZihxIT09b3x8IXApKytyCnE9bysxCnA9ITF9ZWxzZSBpZihuPT09MTMpeysrcgpxPW8rMQpwPSEw
-fX1mPXI+MT9mKygiIChhdCBsaW5lICIrcisiLCBjaGFyYWN0ZXIgIisoZS1xKzEpKyIpXG4iKTpmKygi
-IChhdCBjaGFyYWN0ZXIgIisoZSsxKSsiKVxuIikKbT1kLmxlbmd0aApmb3Iobz1lO288bTsrK28pe249
-Qy54Qi5PKGQsbykKaWYobj09PTEwfHxuPT09MTMpe209bwpicmVha319aWYobS1xPjc4KWlmKGUtcTw3
-NSl7bD1xKzc1Cms9cQpqPSIiCmk9Ii4uLiJ9ZWxzZXtpZihtLWU8NzUpe2s9bS03NQpsPW0KaT0iIn1l
-bHNle2s9ZS0zNgpsPWUrMzYKaT0iLi4uIn1qPSIuLi4ifWVsc2V7bD1tCms9cQpqPSIiCmk9IiJ9aD1D
-LnhCLk5qKGQsayxsKQpyZXR1cm4gZitqK2graSsiXG4iK0MueEIuVCgiICIsZS1rK2oubGVuZ3RoKSsi
-XlxuIn1lbHNlIHJldHVybiBlIT1udWxsP2YrKCIgKGF0IG9mZnNldCAiK0guRWooZSkrIikiKTpmfSwK
-JGlSejoxfQpQLmNYLnByb3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguR0oodGhpcyxI
-LkxoKHRoaXMpLkMoImNYLkUiKSxiKX0sCkUyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMp
-CnJldHVybiBILksxKHRoaXMscy5LcShjKS5DKCIxKGNYLkUpIikuYShiKSxzLkMoImNYLkUiKSxjKX0s
-CmV2OmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5MaCh0aGlzKQpyZXR1cm4gbmV3IEguVTUodGhpcyxzLkMo
-ImEyKGNYLkUpIikuYShiKSxzLkMoIlU1PGNYLkU+IikpfSwKdHQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4g
-UC5ZMSh0aGlzLGIsSC5MaCh0aGlzKS5DKCJjWC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
-aXMudHQoYSwhMCl9LApnQTpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuZ20odGhpcykKZm9yKHM9MDty
-LkYoKTspKytzCnJldHVybiBzfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdtKHRoaXMpLkYo
-KX0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4hdGhpcy5nbDAodGhpcyl9LAplUjpmdW5jdGlvbihhLGIp
-e3JldHVybiBILmJLKHRoaXMsYixILkxoKHRoaXMpLkMoImNYLkUiKSl9LApncjg6ZnVuY3Rpb24oYSl7
-dmFyIHMscj10aGlzLmdtKHRoaXMpCmlmKCFyLkYoKSl0aHJvdyBILmIoSC5XcCgpKQpzPXIuZ2woKQpp
-ZihyLkYoKSl0aHJvdyBILmIoSC5BbSgpKQpyZXR1cm4gc30sCkU6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
-LHEKUC5rMShiLCJpbmRleCIpCmZvcihzPXRoaXMuZ20odGhpcykscj0wO3MuRigpOyl7cT1zLmdsKCkK
-aWYoYj09PXIpcmV0dXJuIHE7KytyfXRocm93IEguYihQLkNmKGIsdGhpcywiaW5kZXgiLG51bGwscikp
-fSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gUC5FUCh0aGlzLCIoIiwiKSIpfX0KUC5Bbi5wcm90b3R5cGU9
-e30KUC5OMy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJNYXBFbnRyeSgiK0guRWoodGhp
-cy5hKSsiOiAiK0guRWoodGhpcy5iKSsiKSJ9fQpQLmM4LnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihh
-KXtyZXR1cm4gUC5NaC5wcm90b3R5cGUuZ2lPLmNhbGwodGhpcyx0aGlzKX0sCnc6ZnVuY3Rpb24oYSl7
-cmV0dXJuIm51bGwifX0KUC5NaC5wcm90b3R5cGU9e2NvbnN0cnVjdG9yOlAuTWgsJGlNaDoxLApETjpm
-dW5jdGlvbihhLGIpe3JldHVybiB0aGlzPT09Yn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gSC5lUSh0
-aGlzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5NKHRoaXMpKSsi
-JyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKHRoaXMsYi5nV2EoKSxi
-LmduZCgpLGIuZ1ZtKCkpKX0sCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMudyh0aGlzKX19
-ClAuWmQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iIn0sCiRpR3o6MX0KUC5Sbi5wcm90
-b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnc6ZnVuY3Rpb24oYSl7
-dmFyIHM9dGhpcy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwKJGlCTDoxfQpQLm4xLnBy
-b3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5KLmEoYSkKSC5oKGIpCnM9Si5E
-MShiLCI9IikKaWYocz09PS0xKXtpZihiIT09IiIpYS5ZNSgwLFAua3UoYiwwLGIubGVuZ3RoLHRoaXMu
-YSwhMCksIiIpfWVsc2UgaWYocyE9PTApe3I9Qy54Qi5OaihiLDAscykKcT1DLnhCLnluKGIscysxKQpw
-PXRoaXMuYQphLlk1KDAsUC5rdShyLDAsci5sZW5ndGgscCwhMCksUC5rdShxLDAscS5sZW5ndGgscCwh
-MCkpfXJldHVybiBhfSwKJFM6NDF9ClAuY1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJv
-dyBILmIoUC5ycigiSWxsZWdhbCBJUHY0IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJFM6MjF9ClAu
-VkMucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxsZWdhbCBJUHY2
-IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuJDIoYSxu
-dWxsKX0sCiRTOjQ1fQpQLkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYi1h
-PjQpdGhpcy5hLiQyKCJhbiBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFpbiBhIG1heGltdW0gb2YgNCBo
-ZXggZGlnaXRzIixhKQpzPVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwxNikKaWYoczwwfHxzPjY1NTM1
-KXRoaXMuYS4kMigiZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIG9mIGAweDAuLjB4RkZGRmAi
-LGEpCnJldHVybiBzfSwKJFM6NTJ9ClAuRG4ucHJvdG90eXBlPXsKZ25EOmZ1bmN0aW9uKCl7dmFyIHMs
-cixxLHA9dGhpcyxvPXAueAppZihvPT09JCl7bz1wLmEKcz1vLmxlbmd0aCE9PTA/bysiOiI6IiIKcj1w
-LmMKcT1yPT1udWxsCmlmKCFxfHxvPT09ImZpbGUiKXtvPXMrIi8vIgpzPXAuYgppZihzLmxlbmd0aCE9
-PTApbz1vK3MrIkAiCmlmKCFxKW8rPXIKcz1wLmQKaWYocyE9bnVsbClvPW8rIjoiK0guRWoocyl9ZWxz
-ZSBvPXMKbys9cC5lCnM9cC5mCmlmKHMhPW51bGwpbz1vKyI/IitzCnM9cC5yCmlmKHMhPW51bGwpbz1v
-KyIjIitzCm89by5jaGFyQ29kZUF0KDApPT0wP286bwppZihwLng9PT0kKXAueD1vCmVsc2Ugbz1ILnYo
-SC5HUSgiX3RleHQiKSl9cmV0dXJuIG99LApnRmo6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLnkK
-aWYocT09PSQpe3M9ci5lCmlmKHMubGVuZ3RoIT09MCYmQy54Qi5XKHMsMCk9PT00NylzPUMueEIueW4o
-cywxKQpxPXMubGVuZ3RoPT09MD9DLnhEOlAuQUYobmV3IEgubEooSC5WTShzLnNwbGl0KCIvIiksdC5z
-KSx0LmRPLmEoUC5QSCgpKSx0LmRvKSx0Lk4pCmlmKHIueT09PSQpci5zS3AocSkKZWxzZSBxPUgudihI
-LkdRKCJwYXRoU2VnbWVudHMiKSl9cmV0dXJuIHF9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxy
-PXMuegppZihyPT09JCl7cj1KLmhmKHMuZ25EKCkpCmlmKHMuej09PSQpcy56PXIKZWxzZSByPUgudihI
-LkdRKCJoYXNoQ29kZSIpKX1yZXR1cm4gcn0sCmdoWTpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLlEK
-aWYocj09PSQpe3I9cy5mCnI9bmV3IFAuR2ooUC5XWChyPT1udWxsPyIiOnIpLHQuZHcpCmlmKHMuUT09
-PSQpcy5zTk0ocikKZWxzZSByPUgudihILkdRKCJxdWVyeVBhcmFtZXRlcnMiKSl9cmV0dXJuIHJ9LApn
-a3U6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5ifSwKZ0pmOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYwpp
-ZihzPT1udWxsKXJldHVybiIiCmlmKEMueEIubkMocywiWyIpKXJldHVybiBDLnhCLk5qKHMsMSxzLmxl
-bmd0aC0xKQpyZXR1cm4gc30sCmd0cDpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmQKcmV0dXJuIHM9PW51
-bGw/UC53Syh0aGlzLmEpOnN9LApndFA6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLmYKcmV0dXJuIHM9PW51
-bGw/IiI6c30sCmdLYTpmdW5jdGlvbigpe3ZhciBzPXRoaXMucgpyZXR1cm4gcz09bnVsbD8iIjpzfSwK
-aEI6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCmlmKGEubGVuZ3RoIT09cy5sZW5ndGgpcmV0dXJuITEK
-cmV0dXJuIFAuTlIoYSxzKX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGo9
-dGhpcwp0LmM5LmEoYikKcz1qLmEKcj1zPT09ImZpbGUiCnE9ai5iCnA9ai5kCm89ai5jCmlmKCEobyE9
-bnVsbCkpbz1xLmxlbmd0aCE9PTB8fHAhPW51bGx8fHI/IiI6bnVsbApuPWouZQppZighciltPW8hPW51
-bGwmJm4ubGVuZ3RoIT09MAplbHNlIG09ITAKaWYobSYmIUMueEIubkMobiwiLyIpKW49Ii8iK24KbD1u
-Cms9UC5sZShudWxsLDAsMCxiKQpyZXR1cm4gUC5DZyhzLHEsbyxwLGwsayxqLnIpfSwKSmg6ZnVuY3Rp
-b24oYSxiKXt2YXIgcyxyLHEscCxvLG4KZm9yKHM9MCxyPTA7Qy54Qi5RaShiLCIuLi8iLHIpOyl7cis9
-MzsrK3N9cT1DLnhCLmNuKGEsIi8iKQp3aGlsZSghMCl7aWYoIShxPjAmJnM+MCkpYnJlYWsKcD1DLnhC
-LlBrKGEsIi8iLHEtMSkKaWYocDwwKWJyZWFrCm89cS1wCm49byE9PTIKaWYoIW58fG89PT0zKWlmKEMu
-eEIuTyhhLHArMSk9PT00NiluPSFufHxDLnhCLk8oYSxwKzIpPT09NDYKZWxzZSBuPSExCmVsc2Ugbj0h
-MQppZihuKWJyZWFrOy0tcwpxPXB9cmV0dXJuIEMueEIuaTcoYSxxKzEsbnVsbCxDLnhCLnluKGIsci0z
-KnMpKX0sClpJOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLm1TKFAuaEsoYSkpfSwKbVM6ZnVuY3Rpb24o
-YSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT10aGlzLGg9bnVsbAppZihhLmdGaSgpLmxlbmd0aCE9
-PTApe3M9YS5nRmkoKQppZihhLmdjaigpKXtyPWEuZ2t1KCkKcT1hLmdKZihhKQpwPWEuZ3hBKCk/YS5n
-dHAoYSk6aH1lbHNle3A9aApxPXAKcj0iIn1vPVAueGUoYS5nSWkoYSkpCm49YS5nUUQoKT9hLmd0UCgp
-Omh9ZWxzZXtzPWkuYQppZihhLmdjaigpKXtyPWEuZ2t1KCkKcT1hLmdKZihhKQpwPVAud0IoYS5neEEo
-KT9hLmd0cChhKTpoLHMpCm89UC54ZShhLmdJaShhKSkKbj1hLmdRRCgpP2EuZ3RQKCk6aH1lbHNle3I9
-aS5iCnE9aS5jCnA9aS5kCm89aS5lCmlmKGEuZ0lpKGEpPT09IiIpbj1hLmdRRCgpP2EuZ3RQKCk6aS5m
-CmVsc2V7bT1QLnVqKGksbykKaWYobT4wKXtsPUMueEIuTmoobywwLG0pCm89YS5ndFQoKT9sK1AueGUo
-YS5nSWkoYSkpOmwrUC54ZShpLkpoKEMueEIueW4obyxsLmxlbmd0aCksYS5nSWkoYSkpKX1lbHNlIGlm
-KGEuZ3RUKCkpbz1QLnhlKGEuZ0lpKGEpKQplbHNlIGlmKG8ubGVuZ3RoPT09MClpZihxPT1udWxsKW89
-cy5sZW5ndGg9PT0wP2EuZ0lpKGEpOlAueGUoYS5nSWkoYSkpCmVsc2Ugbz1QLnhlKCIvIithLmdJaShh
-KSkKZWxzZXtrPWkuSmgobyxhLmdJaShhKSkKaj1zLmxlbmd0aD09PTAKaWYoIWp8fHEhPW51bGx8fEMu
-eEIubkMobywiLyIpKW89UC54ZShrKQplbHNlIG89UC53RihrLCFqfHxxIT1udWxsKX1uPWEuZ1FEKCk/
-YS5ndFAoKTpofX19cmV0dXJuIFAuQ2cocyxyLHEscCxvLG4sYS5nWjgoKT9hLmdLYSgpOmgpfSwKZ2Nq
-OmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYyE9bnVsbH0sCmd4QTpmdW5jdGlvbigpe3JldHVybiB0aGlz
-LmQhPW51bGx9LApnUUQ6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5mIT1udWxsfSwKZ1o4OmZ1bmN0aW9u
-KCl7cmV0dXJuIHRoaXMuciE9bnVsbH0sCmd0VDpmdW5jdGlvbigpe3JldHVybiBDLnhCLm5DKHRoaXMu
-ZSwiLyIpfSwKdDQ6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLmEKaWYocSE9PSIiJiZxIT09ImZp
-bGUiKXRocm93IEguYihQLkw0KCJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEgIitxKyIg
-VVJJIikpCnE9ci5mCmlmKChxPT1udWxsPyIiOnEpIT09IiIpdGhyb3cgSC5iKFAuTDQodS5pKSkKcT1y
-LnIKaWYoKHE9PW51bGw/IiI6cSkhPT0iIil0aHJvdyBILmIoUC5MNCh1LmwpKQpxPSQud1EoKQppZihI
-Lm9UKHEpKXE9UC5tbihyKQplbHNle2lmKHIuYyE9bnVsbCYmci5nSmYocikhPT0iIilILnYoUC5MNCh1
-LmopKQpzPXIuZ0ZqKCkKUC5rRShzLCExKQpxPVAudmcoQy54Qi5uQyhyLmUsIi8iKT8iLyI6IiIscywi
-LyIpCnE9cS5jaGFyQ29kZUF0KDApPT0wP3E6cX1yZXR1cm4gcX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJu
-IHRoaXMuZ25EKCl9LApETjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT10aGlzCmlmKGI9PW51bGwpcmV0
-dXJuITEKaWYocT09PWIpcmV0dXJuITAKaWYodC5kRC5iKGIpKWlmKHEuYT09PWIuZ0ZpKCkpaWYocS5j
-IT1udWxsPT09Yi5nY2ooKSlpZihxLmI9PT1iLmdrdSgpKWlmKHEuZ0pmKHEpPT09Yi5nSmYoYikpaWYo
-cS5ndHAocSk9PT1iLmd0cChiKSlpZihxLmU9PT1iLmdJaShiKSl7cz1xLmYKcj1zPT1udWxsCmlmKCFy
-PT09Yi5nUUQoKSl7aWYocilzPSIiCmlmKHM9PT1iLmd0UCgpKXtzPXEucgpyPXM9PW51bGwKaWYoIXI9
-PT1iLmdaOCgpKXtpZihyKXM9IiIKcz1zPT09Yi5nS2EoKX1lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ug
-cz0hMX1lbHNlIHM9ITEKZWxzZSBzPSExCmVsc2Ugcz0hMQplbHNlIHM9ITEKZWxzZSBzPSExCmVsc2Ug
-cz0hMQplbHNlIHM9ITEKcmV0dXJuIHN9LApzS3A6ZnVuY3Rpb24oYSl7dGhpcy55PXQuYmsuYShhKX0s
-CnNOTTpmdW5jdGlvbihhKXt0aGlzLlE9dC5jWi5hKGEpfSwKJGlpRDoxLApnRmk6ZnVuY3Rpb24oKXty
-ZXR1cm4gdGhpcy5hfSwKZ0lpOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmV9fQpQLlJaLnByb3RvdHlw
-ZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBQLmVQKEMuWkosSC5oKGEpLEMueE0sITEpfSwKJFM6NX0K
-UC5NRS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMuYixyPXRoaXMuYQpzLmEr
-PXIuYQpyLmE9IiYiCnI9cy5hKz1ILkVqKFAuZVAoQy5GMyxhLEMueE0sITApKQppZihiIT1udWxsJiZi
-Lmxlbmd0aCE9PTApe3MuYT1yKyI9IgpzLmErPUguRWooUC5lUChDLkYzLGIsQy54TSwhMCkpfX0sCiRT
-OjIyfQpQLnk1LnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILmgoYSkKaWYoYj09
-bnVsbHx8dHlwZW9mIGI9PSJzdHJpbmciKXRoaXMuYS4kMihhLEguayhiKSkKZWxzZSBmb3Iocz1KLklU
-KHQudS5hKGIpKSxyPXRoaXMuYTtzLkYoKTspci4kMihhLEguaChzLmdsKCkpKX0sCiRTOjEzfQpQLlBF
-LnByb3RvdHlwZT17CmdsUjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89dGhpcyxuPW51bGwsbT1vLmMK
-aWYobT09bnVsbCl7bT1vLmIKaWYoMD49bS5sZW5ndGgpcmV0dXJuIEguT0gobSwwKQpzPW8uYQptPW1b
-MF0rMQpyPUMueEIuWFUocywiPyIsbSkKcT1zLmxlbmd0aAppZihyPj0wKXtwPVAuUEkocyxyKzEscSxD
-LlZDLCExKQpxPXJ9ZWxzZSBwPW4KbT1vLmM9bmV3IFAucWUoImRhdGEiLCIiLG4sbixQLlBJKHMsbSxx
-LEMuV2QsITEpLHAsbil9cmV0dXJuIG19LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5iCmlmKDA+
-PXIubGVuZ3RoKXJldHVybiBILk9IKHIsMCkKcz10aGlzLmEKcmV0dXJuIHJbMF09PT0tMT8iZGF0YToi
-K3M6c319ClAueUkucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmEKaWYoYT49
-cy5sZW5ndGgpcmV0dXJuIEguT0gocyxhKQpzPXNbYV0KQy5OQS5kdShzLDAsOTYsYikKcmV0dXJuIHN9
-LAokUzoyM30KUC5jNi5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxCmZvcihz
-PWIubGVuZ3RoLHI9MDtyPHM7KytyKXtxPUMueEIuVyhiLHIpXjk2CmlmKHE+PTk2KXJldHVybiBILk9I
-KGEscSkKYVtxXT1jfX0sCiRTOjE0fQpQLnFkLnByb3RvdHlwZT17CiQzOmZ1bmN0aW9uKGEsYixjKXt2
-YXIgcyxyLHEKZm9yKHM9Qy54Qi5XKGIsMCkscj1DLnhCLlcoYiwxKTtzPD1yOysrcyl7cT0oc145Nik+
-Pj4wCmlmKHE+PTk2KXJldHVybiBILk9IKGEscSkKYVtxXT1jfX0sCiRTOjE0fQpQLlVmLnByb3RvdHlw
-ZT17CmdjajpmdW5jdGlvbigpe3JldHVybiB0aGlzLmM+MH0sCmd4QTpmdW5jdGlvbigpe3JldHVybiB0
-aGlzLmM+MCYmdGhpcy5kKzE8dGhpcy5lfSwKZ1FEOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZjx0aGlz
-LnJ9LApnWjg6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yPHRoaXMuYS5sZW5ndGh9LApndFQ6ZnVuY3Rp
-b24oKXtyZXR1cm4gQy54Qi5RaSh0aGlzLmEsIi8iLHRoaXMuZSl9LApnRmk6ZnVuY3Rpb24oKXt2YXIg
-cz10aGlzLngKcmV0dXJuIHM9PW51bGw/dGhpcy54PXRoaXMuVTIoKTpzfSwKVTI6ZnVuY3Rpb24oKXt2
-YXIgcyxyPXRoaXMscT1yLmIKaWYocTw9MClyZXR1cm4iIgpzPXE9PT00CmlmKHMmJkMueEIubkMoci5h
-LCJodHRwIikpcmV0dXJuImh0dHAiCmlmKHE9PT01JiZDLnhCLm5DKHIuYSwiaHR0cHMiKSlyZXR1cm4i
-aHR0cHMiCmlmKHMmJkMueEIubkMoci5hLCJmaWxlIikpcmV0dXJuImZpbGUiCmlmKHE9PT03JiZDLnhC
-Lm5DKHIuYSwicGFja2FnZSIpKXJldHVybiJwYWNrYWdlIgpyZXR1cm4gQy54Qi5OaihyLmEsMCxxKX0s
-CmdrdTpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYyxyPXRoaXMuYiszCnJldHVybiBzPnI/Qy54Qi5Oaih0
-aGlzLmEscixzLTEpOiIifSwKZ0pmOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYwpyZXR1cm4gcz4wP0Mu
-eEIuTmoodGhpcy5hLHMsdGhpcy5kKToiIn0sCmd0cDpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMKaWYo
-ci5neEEoKSlyZXR1cm4gUC5RQShDLnhCLk5qKHIuYSxyLmQrMSxyLmUpLG51bGwpCnM9ci5iCmlmKHM9
-PT00JiZDLnhCLm5DKHIuYSwiaHR0cCIpKXJldHVybiA4MAppZihzPT09NSYmQy54Qi5uQyhyLmEsImh0
-dHBzIikpcmV0dXJuIDQ0MwpyZXR1cm4gMH0sCmdJaTpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi5Oaih0
-aGlzLmEsdGhpcy5lLHRoaXMuZil9LApndFA6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLmYscj10aGlzLnIK
-cmV0dXJuIHM8cj9DLnhCLk5qKHRoaXMuYSxzKzEscik6IiJ9LApnS2E6ZnVuY3Rpb24oKXt2YXIgcz10
-aGlzLnIscj10aGlzLmEKcmV0dXJuIHM8ci5sZW5ndGg/Qy54Qi55bihyLHMrMSk6IiJ9LApnRmo6ZnVu
-Y3Rpb24oKXt2YXIgcyxyLHE9dGhpcy5lLHA9dGhpcy5mLG89dGhpcy5hCmlmKEMueEIuUWkobywiLyIs
-cSkpKytxCmlmKHE9PT1wKXJldHVybiBDLnhECnM9SC5WTShbXSx0LnMpCmZvcihyPXE7cjxwOysrcilp
-ZihDLnhCLk8obyxyKT09PTQ3KXtDLk5tLmkocyxDLnhCLk5qKG8scSxyKSkKcT1yKzF9Qy5ObS5pKHMs
-Qy54Qi5OaihvLHEscCkpCnJldHVybiBQLkFGKHMsdC5OKX0sCmdoWTpmdW5jdGlvbigpe2lmKHRoaXMu
-Zj49dGhpcy5yKXJldHVybiBDLkNNCnJldHVybiBuZXcgUC5HaihQLldYKHRoaXMuZ3RQKCkpLHQuZHcp
-fSwKa1g6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kKzEKcmV0dXJuIHMrYS5sZW5ndGg9PT10aGlzLmUm
-JkMueEIuUWkodGhpcy5hLGEscyl9LApOOTpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLnIscT1zLmEK
-aWYocj49cS5sZW5ndGgpcmV0dXJuIHMKcmV0dXJuIG5ldyBQLlVmKEMueEIuTmoocSwwLHIpLHMuYixz
-LmMscy5kLHMuZSxzLmYscixzLngpfSwKbm06ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxs
-LGssaixpPXRoaXMsaD1udWxsCnQuYzkuYShiKQpzPWkuZ0ZpKCkKcj1zPT09ImZpbGUiCnE9aS5jCnA9
-cT4wP0MueEIuTmooaS5hLGkuYiszLHEpOiIiCm89aS5neEEoKT9pLmd0cChpKTpoCnE9aS5jCmlmKHE+
-MCluPUMueEIuTmooaS5hLHEsaS5kKQplbHNlIG49cC5sZW5ndGghPT0wfHxvIT1udWxsfHxyPyIiOmgK
-cT1pLmEKbT1DLnhCLk5qKHEsaS5lLGkuZikKaWYoIXIpbD1uIT1udWxsJiZtLmxlbmd0aCE9PTAKZWxz
-ZSBsPSEwCmlmKGwmJiFDLnhCLm5DKG0sIi8iKSltPSIvIittCms9UC5sZShoLDAsMCxiKQpsPWkucgpq
-PWw8cS5sZW5ndGg/Qy54Qi55bihxLGwrMSk6aApyZXR1cm4gUC5DZyhzLHAsbixvLG0sayxqKX0sClpJ
-OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLm1TKFAuaEsoYSkpfSwKbVM6ZnVuY3Rpb24oYSl7aWYoYSBp
-bnN0YW5jZW9mIFAuVWYpcmV0dXJuIHRoaXMudTEodGhpcyxhKQpyZXR1cm4gdGhpcy5SZSgpLm1TKGEp
-fSwKdTE6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxjPWIu
-YgppZihjPjApcmV0dXJuIGIKcz1iLmMKaWYocz4wKXtyPWEuYgppZihyPD0wKXJldHVybiBiCnE9cj09
-PTQKaWYocSYmQy54Qi5uQyhhLmEsImZpbGUiKSlwPWIuZSE9PWIuZgplbHNlIGlmKHEmJkMueEIubkMo
-YS5hLCJodHRwIikpcD0hYi5rWCgiODAiKQplbHNlIHA9IShyPT09NSYmQy54Qi5uQyhhLmEsImh0dHBz
-IikpfHwhYi5rWCgiNDQzIikKaWYocCl7bz1yKzEKcmV0dXJuIG5ldyBQLlVmKEMueEIuTmooYS5hLDAs
-bykrQy54Qi55bihiLmEsYysxKSxyLHMrbyxiLmQrbyxiLmUrbyxiLmYrbyxiLnIrbyxhLngpfWVsc2Ug
-cmV0dXJuIHRoaXMuUmUoKS5tUyhiKX1uPWIuZQpjPWIuZgppZihuPT09Yyl7cz1iLnIKaWYoYzxzKXty
-PWEuZgpvPXItYwpyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihhLmEsMCxyKStDLnhCLnluKGIuYSxjKSxh
-LmIsYS5jLGEuZCxhLmUsYytvLHMrbyxhLngpfWM9Yi5hCmlmKHM8Yy5sZW5ndGgpe3I9YS5yCnJldHVy
-biBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4oYyxzKSxhLmIsYS5jLGEuZCxhLmUsYS5m
-LHMrKHItcyksYS54KX1yZXR1cm4gYS5OOSgpfXM9Yi5hCmlmKEMueEIuUWkocywiLyIsbikpe209YS5l
-Cmw9UC5SeCh0aGlzKQprPWw+MD9sOm0Kbz1rLW4KcmV0dXJuIG5ldyBQLlVmKEMueEIuTmooYS5hLDAs
-aykrQy54Qi55bihzLG4pLGEuYixhLmMsYS5kLG0sYytvLGIucitvLGEueCl9aj1hLmUKaT1hLmYKaWYo
-aj09PWkmJmEuYz4wKXtmb3IoO0MueEIuUWkocywiLi4vIixuKTspbis9MwpvPWotbisxCnJldHVybiBu
-ZXcgUC5VZihDLnhCLk5qKGEuYSwwLGopKyIvIitDLnhCLnluKHMsbiksYS5iLGEuYyxhLmQsaixjK28s
-Yi5yK28sYS54KX1oPWEuYQpsPVAuUngodGhpcykKaWYobD49MClnPWwKZWxzZSBmb3IoZz1qO0MueEIu
-UWkoaCwiLi4vIixnKTspZys9MwpmPTAKd2hpbGUoITApe2U9biszCmlmKCEoZTw9YyYmQy54Qi5RaShz
-LCIuLi8iLG4pKSlicmVhazsrK2YKbj1lfWZvcihkPSIiO2k+Zzspey0taQppZihDLnhCLk8oaCxpKT09
-PTQ3KXtpZihmPT09MCl7ZD0iLyIKYnJlYWt9LS1mCmQ9Ii8ifX1pZihpPT09ZyYmYS5iPD0wJiYhQy54
-Qi5RaShoLCIvIixqKSl7bi09ZiozCmQ9IiJ9bz1pLW4rZC5sZW5ndGgKcmV0dXJuIG5ldyBQLlVmKEMu
-eEIuTmooaCwwLGkpK2QrQy54Qi55bihzLG4pLGEuYixhLmMsYS5kLGosYytvLGIucitvLGEueCl9LAp0
-NDpmdW5jdGlvbigpe3ZhciBzLHIscT10aGlzLHA9cS5iCmlmKHA+PTApe3M9IShwPT09NCYmQy54Qi5u
-QyhxLmEsImZpbGUiKSkKcD1zfWVsc2UgcD0hMQppZihwKXRocm93IEguYihQLkw0KCJDYW5ub3QgZXh0
-cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEgIitxLmdGaSgpKyIgVVJJIikpCnA9cS5mCnM9cS5hCmlmKHA8
-cy5sZW5ndGgpe2lmKHA8cS5yKXRocm93IEguYihQLkw0KHUuaSkpCnRocm93IEguYihQLkw0KHUubCkp
-fXI9JC53USgpCmlmKEgub1QocikpcD1QLm1uKHEpCmVsc2V7aWYocS5jPHEuZClILnYoUC5MNCh1Lmop
-KQpwPUMueEIuTmoocyxxLmUscCl9cmV0dXJuIHB9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy55
-CnJldHVybiBzPT1udWxsP3RoaXMueT1DLnhCLmdpTyh0aGlzLmEpOnN9LApETjpmdW5jdGlvbihhLGIp
-e2lmKGI9PW51bGwpcmV0dXJuITEKaWYodGhpcz09PWIpcmV0dXJuITAKcmV0dXJuIHQuZEQuYihiKSYm
-dGhpcy5hPT09Yi53KDApfSwKUmU6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9bnVsbCxxPXMuZ0ZpKCks
-cD1zLmdrdSgpLG89cy5jPjA/cy5nSmYocyk6cixuPXMuZ3hBKCk/cy5ndHAocyk6cixtPXMuYSxsPXMu
-ZixrPUMueEIuTmoobSxzLmUsbCksaj1zLnIKbD1sPGo/cy5ndFAoKTpyCnJldHVybiBQLkNnKHEscCxv
-LG4sayxsLGo8bS5sZW5ndGg/cy5nS2EoKTpyKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0s
-CiRpaUQ6MX0KUC5xZS5wcm90b3R5cGU9e30KVy5xRS5wcm90b3R5cGU9e30KVy5HaC5wcm90b3R5cGU9
-ewpzTFU6ZnVuY3Rpb24oYSxiKXthLmhyZWY9Yn0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFN0cmluZyhh
-KX0sCiRpR2g6MX0KVy5mWS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9
-fQpXLm5CLnByb3RvdHlwZT17JGluQjoxfQpXLkF6LnByb3RvdHlwZT17JGlBejoxfQpXLlFQLnByb3Rv
-dHlwZT17JGlRUDoxfQpXLm54LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0
-aH19Clcub0oucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy5pZC5w
-cm90b3R5cGU9e30KVy5RRi5wcm90b3R5cGU9e30KVy5OaC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEp
-e3JldHVybiBTdHJpbmcoYSl9fQpXLmFlLnByb3RvdHlwZT17CkRjOmZ1bmN0aW9uKGEsYil7cmV0dXJu
-IGEuY3JlYXRlSFRNTERvY3VtZW50KGIpfX0KVy5JQi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3Zh
-ciBzLHI9YS5sZWZ0CnIudG9TdHJpbmcKcj0iUmVjdGFuZ2xlICgiK0guRWoocikrIiwgIgpzPWEudG9w
-CnMudG9TdHJpbmcKcz1yK0guRWoocykrIikgIgpyPWEud2lkdGgKci50b1N0cmluZwpyPXMrSC5Faihy
-KSsiIHggIgpzPWEuaGVpZ2h0CnMudG9TdHJpbmcKcmV0dXJuIHIrSC5FaihzKX0sCkROOmZ1bmN0aW9u
-KGEsYil7dmFyIHMscgppZihiPT1udWxsKXJldHVybiExCmlmKHQucS5iKGIpKXtzPWEubGVmdApzLnRv
-U3RyaW5nCnI9Yi5sZWZ0CnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS50b3AKcy50b1N0cmluZwpyPWIu
-dG9wCnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS53aWR0aApzLnRvU3RyaW5nCnI9Yi53aWR0aApyLnRv
-U3RyaW5nCmlmKHM9PT1yKXtzPWEuaGVpZ2h0CnMudG9TdHJpbmcKcj1iLmhlaWdodApyLnRvU3RyaW5n
-CnI9cz09PXIKcz1yfWVsc2Ugcz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMQpyZXR1cm4g
-c30sCmdpTzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLmxlZnQKcC50b1N0cmluZwpwPUMuQ0QuZ2lP
-KHApCnM9YS50b3AKcy50b1N0cmluZwpzPUMuQ0QuZ2lPKHMpCnI9YS53aWR0aApyLnRvU3RyaW5nCnI9
-Qy5DRC5naU8ocikKcT1hLmhlaWdodApxLnRvU3RyaW5nCnJldHVybiBXLnJFKHAscyxyLEMuQ0QuZ2lP
-KHEpKX0sCiRpdG46MX0KVy5uNy5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5n
-dGh9fQpXLnd6LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEubGVuZ3RofSwK
-cTpmdW5jdGlvbihhLGIpe3ZhciBzCkgudVAoYikKcz10aGlzLmEKaWYoYjwwfHxiPj1zLmxlbmd0aCly
-ZXR1cm4gSC5PSChzLGIpCnJldHVybiB0aGlzLiR0aS5jLmEoc1tiXSl9LApZNTpmdW5jdGlvbihhLGIs
-Yyl7dGhpcy4kdGkuYy5hKGMpCnRocm93IEguYihQLkw0KCJDYW5ub3QgbW9kaWZ5IGxpc3QiKSl9fQpX
-LmN2LnByb3RvdHlwZT17CmdRZzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFcuaTcoYSl9LApnUDpmdW5j
-dGlvbihhKXtyZXR1cm4gbmV3IFcuSTQoYSl9LApzUDpmdW5jdGlvbihhLGIpe3ZhciBzCnQuUS5hKGIp
-CnM9dGhpcy5nUChhKQpzLlYxKDApCnMuRlYoMCxiKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubG9j
-YWxOYW1lfSwKRkY6ZnVuY3Rpb24oYSl7dmFyIHM9ISFhLnNjcm9sbEludG9WaWV3SWZOZWVkZWQKaWYo
-cylhLnNjcm9sbEludG9WaWV3SWZOZWVkZWQoKQplbHNlIGEuc2Nyb2xsSW50b1ZpZXcoKX0sCm56OmZ1
-bmN0aW9uKGEsYixjLGQsZSl7dmFyIHMscj10aGlzLnI2KGEsYyxkLGUpCnN3aXRjaChiLnRvTG93ZXJD
-YXNlKCkpe2Nhc2UiYmVmb3JlYmVnaW4iOnM9YS5wYXJlbnROb2RlCnMudG9TdHJpbmcKSi5FaChzLHIs
-YSkKYnJlYWsKY2FzZSJhZnRlcmJlZ2luIjpzPWEuY2hpbGROb2Rlcwp0aGlzLm1LKGEscixzLmxlbmd0
-aD4wP3NbMF06bnVsbCkKYnJlYWsKY2FzZSJiZWZvcmVlbmQiOmEuYXBwZW5kQ2hpbGQocikKYnJlYWsK
-Y2FzZSJhZnRlcmVuZCI6cz1hLnBhcmVudE5vZGUKcy50b1N0cmluZwpKLkVoKHMscixhLm5leHRTaWJs
-aW5nKQpicmVhawpkZWZhdWx0OkgudihQLnhZKCJJbnZhbGlkIHBvc2l0aW9uICIrYikpfX0sCnI2OmZ1
-bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwCmlmKGM9PW51bGwpe2lmKGQ9PW51bGwpe3M9JC5sdApp
-ZihzPT1udWxsKXtzPUguVk0oW10sdC52KQpyPW5ldyBXLnZEKHMpCkMuTm0uaShzLFcuVHcobnVsbCkp
-CkMuTm0uaShzLFcuQmwoKSkKJC5sdD1yCmQ9cn1lbHNlIGQ9c31zPSQuRVUKaWYocz09bnVsbCl7cz1u
-ZXcgVy5LbyhkKQokLkVVPXMKYz1zfWVsc2V7cy5hPWQKYz1zfX1lbHNlIGlmKGQhPW51bGwpdGhyb3cg
-SC5iKFAueFkoInZhbGlkYXRvciBjYW4gb25seSBiZSBwYXNzZWQgaWYgdHJlZVNhbml0aXplciBpcyBu
-dWxsIikpCmlmKCQueG89PW51bGwpe3M9ZG9jdW1lbnQKcj1zLmltcGxlbWVudGF0aW9uCnIudG9TdHJp
-bmcKcj1DLm1ILkRjKHIsIiIpCiQueG89cgokLkJPPXIuY3JlYXRlUmFuZ2UoKQpyPSQueG8uY3JlYXRl
-RWxlbWVudCgiYmFzZSIpCnQuY1IuYShyKQpzPXMuYmFzZVVSSQpzLnRvU3RyaW5nCnIuaHJlZj1zCiQu
-eG8uaGVhZC5hcHBlbmRDaGlsZChyKX1zPSQueG8KaWYocy5ib2R5PT1udWxsKXtyPXMuY3JlYXRlRWxl
-bWVudCgiYm9keSIpCkMuQlouc0dTKHMsdC5wLmEocikpfXM9JC54bwppZih0LnAuYihhKSl7cz1zLmJv
-ZHkKcy50b1N0cmluZwpxPXN9ZWxzZXtzLnRvU3RyaW5nCnE9cy5jcmVhdGVFbGVtZW50KGEudGFnTmFt
-ZSkKJC54by5ib2R5LmFwcGVuZENoaWxkKHEpfWlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGlu
-IHdpbmRvdy5SYW5nZS5wcm90b3R5cGUmJiFDLk5tLnRnKEMuU3EsYS50YWdOYW1lKSl7JC5CTy5zZWxl
-Y3ROb2RlQ29udGVudHMocSkKcz0kLkJPCnMudG9TdHJpbmcKcD1zLmNyZWF0ZUNvbnRleHR1YWxGcmFn
-bWVudChiPT1udWxsPyJudWxsIjpiKX1lbHNle0oud2YocSxiKQpwPSQueG8uY3JlYXRlRG9jdW1lbnRG
-cmFnbWVudCgpCmZvcig7cz1xLmZpcnN0Q2hpbGQscyE9bnVsbDspcC5hcHBlbmRDaGlsZChzKX1pZihx
-IT09JC54by5ib2R5KUouTHQocSkKYy5QbihwKQpkb2N1bWVudC5hZG9wdE5vZGUocCkKcmV0dXJuIHB9
-LApBSDpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIHRoaXMucjYoYSxiLGMsbnVsbCl9LApzaGY6ZnVuY3Rp
-b24oYSxiKXt0aGlzLllDKGEsYil9LApwazpmdW5jdGlvbihhLGIsYyl7dGhpcy5zYTQoYSxudWxsKQph
-LmFwcGVuZENoaWxkKHRoaXMucjYoYSxiLG51bGwsYykpfSwKWUM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4g
-dGhpcy5wayhhLGIsbnVsbCl9LApzUk46ZnVuY3Rpb24oYSxiKXthLmlubmVySFRNTD1ifSwKZ25zOmZ1
-bmN0aW9uKGEpe3JldHVybiBhLnRhZ05hbWV9LApnVmw6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLmV1
-KGEsImNsaWNrIiwhMSx0LmspfSwKJGljdjoxfQpXLkN2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
-e3JldHVybiB0LmguYih0LkEuYShhKSl9LAokUzoyNX0KVy5lYS5wcm90b3R5cGU9eyRpZWE6MX0KVy5E
-MC5wcm90b3R5cGU9ewpPbjpmdW5jdGlvbihhLGIsYyxkKXt0LmJ3LmEoYykKaWYoYyE9bnVsbCl0aGlz
-LnYoYSxiLGMsZCl9LApCOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gdGhpcy5PbihhLGIsYyxudWxsKX0s
-CnY6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGEuYWRkRXZlbnRMaXN0ZW5lcihiLEgudFIodC5idy5h
-KGMpLDEpLGQpfSwKJGlEMDoxfQpXLmhILnByb3RvdHlwZT17JGloSDoxfQpXLmg0LnByb3RvdHlwZT17
-CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19ClcuYnIucHJvdG90eXBlPXsKZ0E6ZnVuY3Rp
-b24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy5WYi5wcm90b3R5cGU9ewpzR1M6ZnVuY3Rpb24oYSxiKXth
-LmJvZHk9Yn19ClcuZkoucHJvdG90eXBlPXsKZW86ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGEub3Bl
-bihiLGMsITApfSwKJGlmSjoxfQpXLndhLnByb3RvdHlwZT17fQpXLlNnLnByb3RvdHlwZT17JGlTZzox
-fQpXLnc3LnByb3RvdHlwZT17CmdEcjpmdW5jdGlvbihhKXtpZigib3JpZ2luIiBpbiBhKXJldHVybiBh
-Lm9yaWdpbgpyZXR1cm4gSC5FaihhLnByb3RvY29sKSsiLy8iK0guRWooYS5ob3N0KX0sCnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIFN0cmluZyhhKX0sCiRpdzc6MX0KVy5Bai5wcm90b3R5cGU9eyRpQWo6MX0KVy5l
-Ny5wcm90b3R5cGU9ewpncjg6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hLHI9cy5jaGlsZE5vZGVzLmxl
-bmd0aAppZihyPT09MCl0aHJvdyBILmIoUC5QVigiTm8gZWxlbWVudHMiKSkKaWYocj4xKXRocm93IEgu
-YihQLlBWKCJNb3JlIHRoYW4gb25lIGVsZW1lbnQiKSkKcz1zLmZpcnN0Q2hpbGQKcy50b1N0cmluZwpy
-ZXR1cm4gc30sCkZWOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbwp0LmVoLmEoYikKaWYoYiBpbnN0
-YW5jZW9mIFcuZTcpe3M9Yi5hCnI9dGhpcy5hCmlmKHMhPT1yKWZvcihxPXMuY2hpbGROb2Rlcy5sZW5n
-dGgscD0wO3A8cTsrK3Ape289cy5maXJzdENoaWxkCm8udG9TdHJpbmcKci5hcHBlbmRDaGlsZChvKX1y
-ZXR1cm59Zm9yKHM9Yi5nbShiKSxyPXRoaXMuYTtzLkYoKTspci5hcHBlbmRDaGlsZChzLmdsKCkpfSwK
-WTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKdC5BLmEoYykKcz10aGlzLmEKcj1zLmNoaWxkTm9kZXMK
-aWYoYjwwfHxiPj1yLmxlbmd0aClyZXR1cm4gSC5PSChyLGIpCnMucmVwbGFjZUNoaWxkKGMscltiXSl9
-LApnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEuY2hpbGROb2RlcwpyZXR1cm4gbmV3IFcuVzkocyxz
-Lmxlbmd0aCxILnoocykuQygiVzk8R20uRT4iKSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5h
-LmNoaWxkTm9kZXMubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe3ZhciBzCkgudVAoYikKcz10aGlzLmEu
-Y2hpbGROb2RlcwppZihiPDB8fGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHNbYl19
-fQpXLnVILnByb3RvdHlwZT17CndnOmZ1bmN0aW9uKGEpe3ZhciBzPWEucGFyZW50Tm9kZQppZihzIT1u
-dWxsKXMucmVtb3ZlQ2hpbGQoYSl9LApENDpmdW5jdGlvbihhKXt2YXIgcwpmb3IoO3M9YS5maXJzdENo
-aWxkLHMhPW51bGw7KWEucmVtb3ZlQ2hpbGQocyl9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzPWEubm9kZVZh
-bHVlCnJldHVybiBzPT1udWxsP3RoaXMuVShhKTpzfSwKc2E0OmZ1bmN0aW9uKGEsYil7YS50ZXh0Q29u
-dGVudD1ifSwKbUs6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBhLmluc2VydEJlZm9yZShiLGMpfSwKJGl1
-SDoxfQpXLkJILnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCnE6ZnVu
-Y3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+Pj4wIT09Ynx8Yj49YS5sZW5ndGgpdGhyb3cgSC5iKFAuQ2Yo
-YixhLG51bGwsbnVsbCxudWxsKSkKcmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIsYyl7dC5BLmEo
-YykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBhc3NpZ24gZWxlbWVudCBvZiBpbW11dGFibGUgTGlzdC4i
-KSl9LApndEg6ZnVuY3Rpb24oYSl7aWYoYS5sZW5ndGg+MClyZXR1cm4gYVswXQp0aHJvdyBILmIoUC5Q
-VigiTm8gZWxlbWVudHMiKSl9LApFOmZ1bmN0aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1
-cm4gSC5PSChhLGIpCnJldHVybiBhW2JdfSwKJGliUToxLAokaVhqOjEsCiRpY1g6MSwKJGl6TToxfQpX
-LlNOLnByb3RvdHlwZT17fQpXLmV3LnByb3RvdHlwZT17JGlldzoxfQpXLmxwLnByb3RvdHlwZT17CmdB
-OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19ClcuVGIucHJvdG90eXBlPXsKcjY6ZnVuY3Rpb24o
-YSxiLGMsZCl7dmFyIHMscgppZigiY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50IiBpbiB3aW5kb3cuUmFu
-Z2UucHJvdG90eXBlKXJldHVybiB0aGlzLkRXKGEsYixjLGQpCnM9Vy5VOSgiPHRhYmxlPiIrSC5Faihi
-KSsiPC90YWJsZT4iLGMsZCkKcj1kb2N1bWVudC5jcmVhdGVEb2N1bWVudEZyYWdtZW50KCkKci50b1N0
-cmluZwpzLnRvU3RyaW5nCm5ldyBXLmU3KHIpLkZWKDAsbmV3IFcuZTcocykpCnJldHVybiByfX0KVy5J
-di5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscAppZigiY3JlYXRlQ29u
-dGV4dHVhbEZyYWdtZW50IiBpbiB3aW5kb3cuUmFuZ2UucHJvdG90eXBlKXJldHVybiB0aGlzLkRXKGEs
-YixjLGQpCnM9ZG9jdW1lbnQKcj1zLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpzPUMuSWUucjYocy5j
-cmVhdGVFbGVtZW50KCJ0YWJsZSIpLGIsYyxkKQpzLnRvU3RyaW5nCnM9bmV3IFcuZTcocykKcT1zLmdy
-OChzKQpxLnRvU3RyaW5nCnM9bmV3IFcuZTcocSkKcD1zLmdyOChzKQpyLnRvU3RyaW5nCnAudG9TdHJp
-bmcKbmV3IFcuZTcocikuRlYoMCxuZXcgVy5lNyhwKSkKcmV0dXJuIHJ9fQpXLldQLnByb3RvdHlwZT17
-CnI2OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQppZigiY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50
-IiBpbiB3aW5kb3cuUmFuZ2UucHJvdG90eXBlKXJldHVybiB0aGlzLkRXKGEsYixjLGQpCnM9ZG9jdW1l
-bnQKcj1zLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpzPUMuSWUucjYocy5jcmVhdGVFbGVtZW50KCJ0
-YWJsZSIpLGIsYyxkKQpzLnRvU3RyaW5nCnM9bmV3IFcuZTcocykKcT1zLmdyOChzKQpyLnRvU3RyaW5n
-CnEudG9TdHJpbmcKbmV3IFcuZTcocikuRlYoMCxuZXcgVy5lNyhxKSkKcmV0dXJuIHJ9fQpXLnlZLnBy
-b3RvdHlwZT17CnBrOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCnRoaXMuc2E0KGEsbnVsbCkKcz1hLmNv
-bnRlbnQKcy50b1N0cmluZwpKLmJUKHMpCnI9dGhpcy5yNihhLGIsbnVsbCxjKQphLmNvbnRlbnQuYXBw
-ZW5kQ2hpbGQocil9LApZQzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLnBrKGEsYixudWxsKX0sCiRp
-eVk6MX0KVy53Ni5wcm90b3R5cGU9e30KVy5LNS5wcm90b3R5cGU9ewpQbzpmdW5jdGlvbihhLGIsYyl7
-dmFyIHM9Vy5QMShhLm9wZW4oYixjKSkKcmV0dXJuIHN9LApnbVc6ZnVuY3Rpb24oYSl7cmV0dXJuIGEu
-bG9jYXRpb259LAp1czpmdW5jdGlvbihhLGIpe3JldHVybiBhLmNvbmZpcm0oYil9LAokaUs1OjEsCiRp
-djY6MX0KVy5DbS5wcm90b3R5cGU9eyRpQ206MX0KVy5DUS5wcm90b3R5cGU9eyRpQ1E6MX0KVy53NC5w
-cm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHI9YS5sZWZ0CnIudG9TdHJpbmcKcj0iUmVjdGFu
-Z2xlICgiK0guRWoocikrIiwgIgpzPWEudG9wCnMudG9TdHJpbmcKcz1yK0guRWoocykrIikgIgpyPWEu
-d2lkdGgKci50b1N0cmluZwpyPXMrSC5FaihyKSsiIHggIgpzPWEuaGVpZ2h0CnMudG9TdHJpbmcKcmV0
-dXJuIHIrSC5FaihzKX0sCkROOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZihiPT1udWxsKXJldHVybiEx
-CmlmKHQucS5iKGIpKXtzPWEubGVmdApzLnRvU3RyaW5nCnI9Yi5sZWZ0CnIudG9TdHJpbmcKaWYocz09
-PXIpe3M9YS50b3AKcy50b1N0cmluZwpyPWIudG9wCnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS53aWR0
-aApzLnRvU3RyaW5nCnI9Yi53aWR0aApyLnRvU3RyaW5nCmlmKHM9PT1yKXtzPWEuaGVpZ2h0CnMudG9T
-dHJpbmcKcj1iLmhlaWdodApyLnRvU3RyaW5nCnI9cz09PXIKcz1yfWVsc2Ugcz0hMX1lbHNlIHM9ITF9
-ZWxzZSBzPSExfWVsc2Ugcz0hMQpyZXR1cm4gc30sCmdpTzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1h
-LmxlZnQKcC50b1N0cmluZwpwPUMuQ0QuZ2lPKHApCnM9YS50b3AKcy50b1N0cmluZwpzPUMuQ0QuZ2lP
-KHMpCnI9YS53aWR0aApyLnRvU3RyaW5nCnI9Qy5DRC5naU8ocikKcT1hLmhlaWdodApxLnRvU3RyaW5n
-CnJldHVybiBXLnJFKHAscyxyLEMuQ0QuZ2lPKHEpKX19ClcucmgucHJvdG90eXBlPXsKZ0E6ZnVuY3Rp
-b24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYj4+PjAhPT1i
-fHxiPj1hLmxlbmd0aCl0aHJvdyBILmIoUC5DZihiLGEsbnVsbCxudWxsLG51bGwpKQpyZXR1cm4gYVti
-XX0sClk1OmZ1bmN0aW9uKGEsYixjKXt0LkEuYShjKQp0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGFzc2ln
-biBlbGVtZW50IG9mIGltbXV0YWJsZSBMaXN0LiIpKX0sCkU6ZnVuY3Rpb24oYSxiKXtpZihiPDB8fGI+
-PWEubGVuZ3RoKXJldHVybiBILk9IKGEsYikKcmV0dXJuIGFbYl19LAokaWJROjEsCiRpWGo6MSwKJGlj
-WDoxLAokaXpNOjF9ClcuY2YucHJvdG90eXBlPXsKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8K
-dC5lQS5hKGIpCmZvcihzPXRoaXMuZ3ZjKCkscj1zLmxlbmd0aCxxPXRoaXMuYSxwPTA7cDxzLmxlbmd0
-aDtzLmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsrcCl7bz1zW3BdCmIuJDIobyxxLmdldEF0dHJpYnV0
-ZShvKSl9fSwKZ3ZjOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhpcy5hLmF0dHJpYnV0ZXMK
-bS50b1N0cmluZwpzPUguVk0oW10sdC5zKQpmb3Iocj1tLmxlbmd0aCxxPXQuaDkscD0wO3A8cjsrK3Ap
-e2lmKHA+PW0ubGVuZ3RoKXJldHVybiBILk9IKG0scCkKbz1xLmEobVtwXSkKaWYoby5uYW1lc3BhY2VV
-Ukk9PW51bGwpe249by5uYW1lCm4udG9TdHJpbmcKQy5ObS5pKHMsbil9fXJldHVybiBzfSwKZ2wwOmZ1
-bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aD09PTB9fQpXLmk3LnByb3RvdHlwZT17Cng0
-OmZ1bmN0aW9uKGEpe3ZhciBzPUgub1QodGhpcy5hLmhhc0F0dHJpYnV0ZShhKSkKcmV0dXJuIHN9LApx
-OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS5nZXRBdHRyaWJ1dGUoSC5oKGIpKX0sClk1OmZ1bmN0
-aW9uKGEsYixjKXt0aGlzLmEuc2V0QXR0cmlidXRlKGIsYyl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4g
-dGhpcy5ndmMoKS5sZW5ndGh9fQpXLlN5LnByb3RvdHlwZT17Cng0OmZ1bmN0aW9uKGEpe3ZhciBzPUgu
-b1QodGhpcy5hLmEuaGFzQXR0cmlidXRlKCJkYXRhLSIrdGhpcy5PVShhKSkpCnJldHVybiBzfSwKcTpm
-dW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEuYS5nZXRBdHRyaWJ1dGUoImRhdGEtIit0aGlzLk9VKEgu
-aChiKSkpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuYS5hLnNldEF0dHJpYnV0ZSgiZGF0YS0iK3Ro
-aXMuT1UoYiksYyl9LApLOmZ1bmN0aW9uKGEsYil7dGhpcy5hLksoMCxuZXcgVy5LUyh0aGlzLHQuZUEu
-YShiKSkpfSwKZ3ZjOmZ1bmN0aW9uKCl7dmFyIHM9SC5WTShbXSx0LnMpCnRoaXMuYS5LKDAsbmV3IFcu
-QTModGhpcyxzKSkKcmV0dXJuIHN9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ndmMoKS5sZW5n
-dGh9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3RoPT09MH0sCm46ZnVuY3Rp
-b24oYSl7dmFyIHMscixxPUguVk0oYS5zcGxpdCgiLSIpLHQucykKZm9yKHM9MTtzPHEubGVuZ3RoOysr
-cyl7cj1xW3NdCmlmKHIubGVuZ3RoPjApQy5ObS5ZNShxLHMsclswXS50b1VwcGVyQ2FzZSgpK0ouS1Yo
-ciwxKSl9cmV0dXJuIEMuTm0uayhxLCIiKX0sCk9VOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8KZm9y
-KHM9YS5sZW5ndGgscj0wLHE9IiI7cjxzOysrcil7cD1hW3JdCm89cC50b0xvd2VyQ2FzZSgpCnE9KHAh
-PT1vJiZyPjA/cSsiLSI6cSkrb31yZXR1cm4gcS5jaGFyQ29kZUF0KDApPT0wP3E6cX19ClcuS1MucHJv
-dG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXtpZihKLmF1KGEsImRhdGEtIikpdGhpcy5iLiQyKHRoaXMu
-YS5uKEMueEIueW4oYSw1KSksYil9LAokUzoxNX0KVy5BMy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihh
-LGIpe2lmKEouYXUoYSwiZGF0YS0iKSlDLk5tLmkodGhpcy5iLHRoaXMuYS5uKEMueEIueW4oYSw1KSkp
-fSwKJFM6MTV9ClcuSTQucHJvdG90eXBlPXsKRDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89UC5Mcyh0
-Lk4pCmZvcihzPXRoaXMuYS5jbGFzc05hbWUuc3BsaXQoIiAiKSxyPXMubGVuZ3RoLHE9MDtxPHI7Kytx
-KXtwPUouVDAoc1txXSkKaWYocC5sZW5ndGghPT0wKW8uaSgwLHApfXJldHVybiBvfSwKWDpmdW5jdGlv
-bihhKXt0aGlzLmEuY2xhc3NOYW1lPXQuQy5hKGEpLmsoMCwiICIpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0
-dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEu
-Y2xhc3NMaXN0Lmxlbmd0aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xp
-c3QubGVuZ3RoIT09MH0sClYxOmZ1bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05hbWU9IiJ9LAp0ZzpmdW5j
-dGlvbihhLGIpe3ZhciBzPXRoaXMuYS5jbGFzc0xpc3QuY29udGFpbnMoYikKcmV0dXJuIHN9LAppOmZ1
-bmN0aW9uKGEsYil7dmFyIHMscgpILmgoYikKcz10aGlzLmEuY2xhc3NMaXN0CnI9cy5jb250YWlucyhi
-KQpzLmFkZChiKQpyZXR1cm4hcn0sClI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYodHlwZW9mIGI9
-PSJzdHJpbmciKXtzPXRoaXMuYS5jbGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMucmVtb3ZlKGIpCnE9
-cn1lbHNlIHE9ITEKcmV0dXJuIHF9LApGVjpmdW5jdGlvbihhLGIpe1cuVE4odGhpcy5hLHQuUS5hKGIp
-KX19ClcuRmsucHJvdG90eXBlPXt9ClcuUk8ucHJvdG90eXBlPXt9ClcuZXUucHJvdG90eXBlPXt9Clcu
-eEMucHJvdG90eXBlPXt9Clcudk4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
-YS4kMSh0LkIuYShhKSl9LAokUzoyN30KVy5KUS5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhKXt2YXIg
-cwppZigkLm9yLmE9PT0wKXtmb3Iocz0wO3M8MjYyOysrcykkLm9yLlk1KDAsQy5jbVtzXSxXLnBTKCkp
-CmZvcihzPTA7czwxMjsrK3MpJC5vci5ZNSgwLEMuQklbc10sVy5WNCgpKX19LAppMDpmdW5jdGlvbihh
-KXtyZXR1cm4gJC5BTigpLnRnKDAsVy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9JC5v
-ci5xKDAsSC5FaihXLnJTKGEpKSsiOjoiK2IpCmlmKHM9PW51bGwpcz0kLm9yLnEoMCwiKjo6IitiKQpp
-ZihzPT1udWxsKXJldHVybiExCnJldHVybiBILnk4KHMuJDQoYSxiLGMsdGhpcykpfSwKJGlrRjoxfQpX
-LkdtLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5XOShhLHRoaXMuZ0EoYSks
-SC56KGEpLkMoIlc5PEdtLkU+IikpfX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1
-cm4gQy5ObS5Wcih0aGlzLmEsbmV3IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBD
-Lk5tLlZyKHRoaXMuYSxuZXcgVy5FZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQx
-OmZ1bmN0aW9uKGEpe3JldHVybiB0LkUuYShhKS5pMCh0aGlzLmEpfSwKJFM6MTZ9ClcuRWcucHJvdG90
-eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuRS5hKGEpLkViKHRoaXMuYSx0aGlzLmIsdGhpcy5j
-KX0sCiRTOjE2fQpXLm02LnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQp0
-aGlzLmEuRlYoMCxjKQpzPWIuZXYoMCxuZXcgVy5FbygpKQpyPWIuZXYoMCxuZXcgVy5XaygpKQp0aGlz
-LmIuRlYoMCxzKQpxPXRoaXMuYwpxLkZWKDAsQy54RCkKcS5GVigwLHIpfSwKaTA6ZnVuY3Rpb24oYSl7
-cmV0dXJuIHRoaXMuYS50ZygwLFcuclMoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMs
-cj1XLnJTKGEpLHE9cy5jCmlmKHEudGcoMCxILkVqKHIpKyI6OiIrYikpcmV0dXJuIHMuZC5EdChjKQpl
-bHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4gcy5kLkR0KGMpCmVsc2V7cT1zLmIKaWYocS50Zygw
-LEguRWoocikrIjo6IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4hMApl
-bHNlIGlmKHEudGcoMCxILkVqKHIpKyI6OioiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6KiIp
-KXJldHVybiEwfXJldHVybiExfSwKJGlrRjoxfQpXLkVvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
-e3JldHVybiFDLk5tLnRnKEMuQkksSC5oKGEpKX0sCiRTOjd9ClcuV2sucHJvdG90eXBlPXsKJDE6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIEMuTm0udGcoQy5CSSxILmgoYSkpfSwKJFM6N30KVy5jdC5wcm90b3R5cGU9
-ewpFYjpmdW5jdGlvbihhLGIsYyl7aWYodGhpcy5qRihhLGIsYykpcmV0dXJuITAKaWYoYj09PSJ0ZW1w
-bGF0ZSImJmM9PT0iIilyZXR1cm4hMAppZihhLmdldEF0dHJpYnV0ZSgidGVtcGxhdGUiKT09PSIiKXJl
-dHVybiB0aGlzLmUudGcoMCxiKQpyZXR1cm4hMX19ClcuSUEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
-YSl7cmV0dXJuIlRFTVBMQVRFOjoiK0guRWooSC5oKGEpKX0sCiRTOjV9ClcuT3cucHJvdG90eXBlPXsK
-aTA6ZnVuY3Rpb24oYSl7dmFyIHMKaWYodC5ldy5iKGEpKXJldHVybiExCnM9dC5nNy5iKGEpCmlmKHMm
-JlcuclMoYSk9PT0iZm9yZWlnbk9iamVjdCIpcmV0dXJuITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0s
-CkViOmZ1bmN0aW9uKGEsYixjKXtpZihiPT09ImlzInx8Qy54Qi5uQyhiLCJvbiIpKXJldHVybiExCnJl
-dHVybiB0aGlzLmkwKGEpfSwKJGlrRjoxfQpXLlc5LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24oKXt2YXIg
-cz10aGlzLHI9cy5jKzEscT1zLmIKaWYocjxxKXtzLnNwKEoueDkocy5hLHIpKQpzLmM9cgpyZXR1cm4h
-MH1zLnNwKG51bGwpCnMuYz1xCnJldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwK
-c3A6ZnVuY3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KVy5kVy5w
-cm90b3R5cGU9eyRpRDA6MSwkaXY2OjF9ClcubWsucHJvdG90eXBlPXskaXkwOjF9ClcuS28ucHJvdG90
-eXBlPXsKUG46ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPW5ldyBXLmZtKHMpCnMuYj0hMQpyLiQyKGEs
-bnVsbCkKZm9yKDtzLmI7KXtzLmI9ITEKci4kMihhLG51bGwpfX0sCkVQOmZ1bmN0aW9uKGEsYil7dmFy
-IHM9dGhpcy5iPSEwCmlmKGIhPW51bGw/YiE9PWEucGFyZW50Tm9kZTpzKUouTHQoYSkKZWxzZSBiLnJl
-bW92ZUNoaWxkKGEpfSwKSTQ6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG49ITAsbT1udWxsLGw9
-bnVsbAp0cnl7bT1KLmlnKGEpCmw9bS5hLmdldEF0dHJpYnV0ZSgiaXMiKQp0LmguYShhKQpzPWZ1bmN0
-aW9uKGMpe2lmKCEoYy5hdHRyaWJ1dGVzIGluc3RhbmNlb2YgTmFtZWROb2RlTWFwKSlyZXR1cm4gdHJ1
-ZQppZihjLmlkPT0nbGFzdENoaWxkJ3x8Yy5uYW1lPT0nbGFzdENoaWxkJ3x8Yy5pZD09J3ByZXZpb3Vz
-U2libGluZyd8fGMubmFtZT09J3ByZXZpb3VzU2libGluZyd8fGMuaWQ9PSdjaGlsZHJlbid8fGMubmFt
-ZT09J2NoaWxkcmVuJylyZXR1cm4gdHJ1ZQp2YXIgaz1jLmNoaWxkTm9kZXMKaWYoYy5sYXN0Q2hpbGQm
-JmMubGFzdENoaWxkIT09a1trLmxlbmd0aC0xXSlyZXR1cm4gdHJ1ZQppZihjLmNoaWxkcmVuKWlmKCEo
-Yy5jaGlsZHJlbiBpbnN0YW5jZW9mIEhUTUxDb2xsZWN0aW9ufHxjLmNoaWxkcmVuIGluc3RhbmNlb2Yg
-Tm9kZUxpc3QpKXJldHVybiB0cnVlCnZhciBqPTAKaWYoYy5jaGlsZHJlbilqPWMuY2hpbGRyZW4ubGVu
-Z3RoCmZvcih2YXIgaT0wO2k8ajtpKyspe3ZhciBoPWMuY2hpbGRyZW5baV0KaWYoaC5pZD09J2F0dHJp
-YnV0ZXMnfHxoLm5hbWU9PSdhdHRyaWJ1dGVzJ3x8aC5pZD09J2xhc3RDaGlsZCd8fGgubmFtZT09J2xh
-c3RDaGlsZCd8fGguaWQ9PSdwcmV2aW91c1NpYmxpbmcnfHxoLm5hbWU9PSdwcmV2aW91c1NpYmxpbmcn
-fHxoLmlkPT0nY2hpbGRyZW4nfHxoLm5hbWU9PSdjaGlsZHJlbicpcmV0dXJuIHRydWV9cmV0dXJuIGZh
-bHNlfShhKQpuPUgub1Qocyk/ITA6IShhLmF0dHJpYnV0ZXMgaW5zdGFuY2VvZiBOYW1lZE5vZGVNYXAp
-fWNhdGNoKHApe0guUnUocCl9cj0iZWxlbWVudCB1bnByaW50YWJsZSIKdHJ5e3I9Si5qKGEpfWNhdGNo
-KHApe0guUnUocCl9dHJ5e3E9Vy5yUyhhKQp0aGlzLmtSKHQuaC5hKGEpLGIsbixyLHEsdC5mLmEobSks
-SC5rKGwpKX1jYXRjaChwKXtpZihILlJ1KHApIGluc3RhbmNlb2YgUC51KXRocm93IHAKZWxzZXt0aGlz
-LkVQKGEsYikKd2luZG93Cm89IlJlbW92aW5nIGNvcnJ1cHRlZCBlbGVtZW50ICIrSC5FaihyKQppZih0
-eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUud2FybihvKX19fSwKa1I6ZnVu
-Y3Rpb24oYSxiLGMsZCxlLGYsZyl7dmFyIHMscixxLHAsbyxuLG09dGhpcwppZihjKXttLkVQKGEsYikK
-d2luZG93CnM9IlJlbW92aW5nIGVsZW1lbnQgZHVlIHRvIGNvcnJ1cHRlZCBhdHRyaWJ1dGVzIG9uIDwi
-K2QrIj4iCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKHMp
-CnJldHVybn1pZighbS5hLmkwKGEpKXttLkVQKGEsYikKd2luZG93CnM9IlJlbW92aW5nIGRpc2FsbG93
-ZWQgZWxlbWVudCA8IitILkVqKGUpKyI+IGZyb20gIitILkVqKGIpCmlmKHR5cGVvZiBjb25zb2xlIT0i
-dW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKHMpCnJldHVybn1pZihnIT1udWxsKWlmKCFtLmEu
-RWIoYSwiaXMiLGcpKXttLkVQKGEsYikKd2luZG93CnM9IlJlbW92aW5nIGRpc2FsbG93ZWQgdHlwZSBl
-eHRlbnNpb24gPCIrSC5FaihlKSsnIGlzPSInK2crJyI+JwppZih0eXBlb2YgY29uc29sZSE9InVuZGVm
-aW5lZCIpd2luZG93LmNvbnNvbGUud2FybihzKQpyZXR1cm59cz1mLmd2YygpCnI9SC5WTShzLnNsaWNl
-KDApLEgudDYocykpCmZvcihxPWYuZ3ZjKCkubGVuZ3RoLTEscz1mLmE7cT49MDstLXEpe2lmKHE+PXIu
-bGVuZ3RoKXJldHVybiBILk9IKHIscSkKcD1yW3FdCm89bS5hCm49Si5jSChwKQpILmgocCkKaWYoIW8u
-RWIoYSxuLHMuZ2V0QXR0cmlidXRlKHApKSl7d2luZG93Cm89IlJlbW92aW5nIGRpc2FsbG93ZWQgYXR0
-cmlidXRlIDwiK0guRWooZSkrIiAiK3ArJz0iJytILkVqKHMuZ2V0QXR0cmlidXRlKHApKSsnIj4nCmlm
-KHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKG8pCnMucmVtb3Zl
-QXR0cmlidXRlKHApfX1pZih0LmFXLmIoYSkpe3M9YS5jb250ZW50CnMudG9TdHJpbmcKbS5QbihzKX19
-LAokaW9uOjF9ClcuZm0ucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4s
-bT10aGlzLmEKc3dpdGNoKGEubm9kZVR5cGUpe2Nhc2UgMTptLkk0KGEsYikKYnJlYWsKY2FzZSA4OmNh
-c2UgMTE6Y2FzZSAzOmNhc2UgNDpicmVhawpkZWZhdWx0Om0uRVAoYSxiKX1zPWEubGFzdENoaWxkCmZv
-cihxPXQuQTtudWxsIT1zOyl7cj1udWxsCnRyeXtyPXMucHJldmlvdXNTaWJsaW5nCmlmKHIhPW51bGwp
-e3A9ci5uZXh0U2libGluZwpvPXMKbz1wPT1udWxsP28hPW51bGw6cCE9PW8KcD1vfWVsc2UgcD0hMQpp
-ZihwKXtwPVAuUFYoIkNvcnJ1cHQgSFRNTCIpCnRocm93IEguYihwKX19Y2F0Y2gobil7SC5SdShuKQpw
-PXEuYShzKQptLmI9ITAKbz1wLnBhcmVudE5vZGUKbz1hPT1udWxsP28hPW51bGw6YSE9PW8KaWYobyl7
-bz1wLnBhcmVudE5vZGUKaWYobyE9bnVsbClvLnJlbW92ZUNoaWxkKHApfWVsc2UgYS5yZW1vdmVDaGls
-ZChwKQpzPW51bGwKcj1hLmxhc3RDaGlsZH1pZihzIT1udWxsKXRoaXMuJDIocyxhKQpzPXJ9fSwKJFM6
-MzB9ClcuTGUucHJvdG90eXBlPXt9ClcuSzcucHJvdG90eXBlPXt9ClcuckIucHJvdG90eXBlPXt9Clcu
-WFcucHJvdG90eXBlPXt9Clcub2EucHJvdG90eXBlPXt9ClAuaUoucHJvdG90eXBlPXsKVkg6ZnVuY3Rp
-b24oYSl7dmFyIHMscj10aGlzLmEscT1yLmxlbmd0aApmb3Iocz0wO3M8cTsrK3MpaWYocltzXT09PWEp
-cmV0dXJuIHMKQy5ObS5pKHIsYSkKQy5ObS5pKHRoaXMuYixudWxsKQpyZXR1cm4gcX0sClB2OmZ1bmN0
-aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMsbz17fQppZihhPT1udWxsKXJldHVybiBhCmlmKEgubChhKSly
-ZXR1cm4gYQppZih0eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKaWYodHlwZW9mIGE9PSJzdHJpbmci
-KXJldHVybiBhCmlmKGEgaW5zdGFuY2VvZiBQLmlQKXJldHVybiBuZXcgRGF0ZShhLmEpCmlmKHQuZnYu
-YihhKSl0aHJvdyBILmIoUC5TWSgic3RydWN0dXJlZCBjbG9uZSBvZiBSZWdFeHAiKSkKaWYodC5jOC5i
-KGEpKXJldHVybiBhCmlmKHQudy5iKGEpKXJldHVybiBhCmlmKHQuSS5iKGEpKXJldHVybiBhCnM9dC5k
-RS5iKGEpfHwhMQppZihzKXJldHVybiBhCmlmKHQuZi5iKGEpKXtyPXAuVkgoYSkKcz1wLmIKaWYocj49
-cy5sZW5ndGgpcmV0dXJuIEguT0gocyxyKQpxPW8uYT1zW3JdCmlmKHEhPW51bGwpcmV0dXJuIHEKcT17
-fQpvLmE9cQpDLk5tLlk1KHMscixxKQphLksoMCxuZXcgUC5qZyhvLHApKQpyZXR1cm4gby5hfWlmKHQu
-ai5iKGEpKXtyPXAuVkgoYSkKbz1wLmIKaWYocj49by5sZW5ndGgpcmV0dXJuIEguT0gobyxyKQpxPW9b
-cl0KaWYocSE9bnVsbClyZXR1cm4gcQpyZXR1cm4gcC5layhhLHIpfWlmKHQuZUguYihhKSl7cj1wLlZI
-KGEpCnM9cC5iCmlmKHI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMscikKcT1vLmI9c1tyXQppZihxIT1u
-dWxsKXJldHVybiBxCnE9e30Kby5iPXEKQy5ObS5ZNShzLHIscSkKcC5pbShhLG5ldyBQLlRhKG8scCkp
-CnJldHVybiBvLmJ9dGhyb3cgSC5iKFAuU1koInN0cnVjdHVyZWQgY2xvbmUgb2Ygb3RoZXIgdHlwZSIp
-KX0sCmVrOmZ1bmN0aW9uKGEsYil7dmFyIHMscj1KLlU2KGEpLHE9ci5nQShhKSxwPW5ldyBBcnJheShx
-KQpDLk5tLlk1KHRoaXMuYixiLHApCmZvcihzPTA7czxxOysrcylDLk5tLlk1KHAscyx0aGlzLlB2KHIu
-cShhLHMpKSkKcmV0dXJuIHB9fQpQLmpnLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5h
-LmFbYV09dGhpcy5iLlB2KGIpfSwKJFM6MzF9ClAuVGEucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxi
-KXt0aGlzLmEuYlthXT10aGlzLmIuUHYoYil9LAokUzoxN30KUC5CZi5wcm90b3R5cGU9ewppbTpmdW5j
-dGlvbihhLGIpe3ZhciBzLHIscSxwCnQuYjguYShiKQpmb3Iocz1PYmplY3Qua2V5cyhhKSxyPXMubGVu
-Z3RoLHE9MDtxPHI7KytxKXtwPXNbcV0KYi4kMihwLGFbcF0pfX19ClAuQXMucHJvdG90eXBlPXsKVjpm
-dW5jdGlvbihhKXt2YXIgcwpILmgoYSkKcz0kLmhHKCkuYgppZih0eXBlb2YgYSE9InN0cmluZyIpSC52
-KEgudEwoYSkpCmlmKHMudGVzdChhKSlyZXR1cm4gYQp0aHJvdyBILmIoUC5MMyhhLCJ2YWx1ZSIsIk5v
-dCBhIHZhbGlkIGNsYXNzIHRva2VuIikpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5EKCkuaygw
-LCIgIil9LApnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLkQoKQpyZXR1cm4gUC5yaihzLHMucixILkxo
-KHMpLmMpfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hPT09MH0sCmdvcjpmdW5jdGlv
-bihhKXtyZXR1cm4gdGhpcy5EKCkuYSE9PTB9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5EKCku
-YX0sCnRnOmZ1bmN0aW9uKGEsYil7dGhpcy5WKGIpCnJldHVybiB0aGlzLkQoKS50ZygwLGIpfSwKaTpm
-dW5jdGlvbihhLGIpe3ZhciBzCkguaChiKQp0aGlzLlYoYikKcz10aGlzLk9TKG5ldyBQLkdFKGIpKQpy
-ZXR1cm4gSC55OChzPT1udWxsPyExOnMpfSwKUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYodHlwZW9m
-IGIhPSJzdHJpbmciKXJldHVybiExCnRoaXMuVihiKQpzPXRoaXMuRCgpCnI9cy5SKDAsYikKdGhpcy5Y
-KHMpCnJldHVybiByfSwKRlY6ZnVuY3Rpb24oYSxiKXt0aGlzLk9TKG5ldyBQLk43KHRoaXMsdC5RLmEo
-YikpKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5EKCkKcmV0dXJuIEguYksocyxiLEguTGgo
-cykuQygibGYuRSIpKX0sCkU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5EKCkuRSgwLGIpfSwKVjE6
-ZnVuY3Rpb24oYSl7dGhpcy5PUyhuZXcgUC51USgpKX0sCk9TOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdC5i
-VS5hKGEpCnM9dGhpcy5EKCkKcj1hLiQxKHMpCnRoaXMuWChzKQpyZXR1cm4gcn19ClAuR0UucHJvdG90
-eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuQy5hKGEpLmkoMCx0aGlzLmEpfSwKJFM6MzN9ClAu
-TjcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5iLHI9SC50NihzKQpyZXR1cm4g
-dC5DLmEoYSkuRlYoMCxuZXcgSC5sSihzLHIuQygicVUoMSkiKS5hKHRoaXMuYS5ndU0oKSksci5DKCJs
-SjwxLHFVPiIpKSl9LAokUzoxOH0KUC51US5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0LkMuYShh
-KQppZihhLmE+MCl7YS5iPWEuYz1hLmQ9YS5lPWEuZj1udWxsCmEuYT0wCmEuUygpfXJldHVybiBudWxs
-fSwKJFM6MTh9ClAuaEYucHJvdG90eXBlPXskaWhGOjF9ClAuUEMucHJvdG90eXBlPXsKJDE6ZnVuY3Rp
-b24oYSl7dmFyIHMKdC5ZLmEoYSkKcz1mdW5jdGlvbihiLGMsZCl7cmV0dXJuIGZ1bmN0aW9uKCl7cmV0
-dXJuIGIoYyxkLHRoaXMsQXJyYXkucHJvdG90eXBlLnNsaWNlLmFwcGx5KGFyZ3VtZW50cykpfX0oUC5S
-NCxhLCExKQpQLkRtKHMsJC53KCksYSkKcmV0dXJuIHN9LAokUzo0fQpQLm10LnByb3RvdHlwZT17CiQx
-OmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgdGhpcy5hKGEpfSwKJFM6NH0KUC5RUy5wcm90b3R5cGU9ewok
-MTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAucjcoYSl9LAokUzozNX0KUC5ucC5wcm90b3R5cGU9ewok
-MTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuVHooYSx0LmFtKX0sCiRTOjQ2fQpQLlV0LnByb3RvdHlw
-ZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5FNChhKX0sCiRTOjM3fQpQLkU0LnByb3RvdHlw
-ZT17CnE6ZnVuY3Rpb24oYSxiKXtpZih0eXBlb2YgYiE9InN0cmluZyImJnR5cGVvZiBiIT0ibnVtYmVy
-Iil0aHJvdyBILmIoUC54WSgicHJvcGVydHkgaXMgbm90IGEgU3RyaW5nIG9yIG51bSIpKQpyZXR1cm4g
-UC5kVSh0aGlzLmFbYl0pfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe2lmKHR5cGVvZiBiIT0ic3RyaW5nIiYm
-dHlwZW9mIGIhPSJudW1iZXIiKXRocm93IEguYihQLnhZKCJwcm9wZXJ0eSBpcyBub3QgYSBTdHJpbmcg
-b3IgbnVtIikpCnRoaXMuYVtiXT1QLndZKGMpfSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJl
-dHVybiExCnJldHVybiBiIGluc3RhbmNlb2YgUC5FNCYmdGhpcy5hPT09Yi5hfSwKdzpmdW5jdGlvbihh
-KXt2YXIgcyxyCnRyeXtzPVN0cmluZyh0aGlzLmEpCnJldHVybiBzfWNhdGNoKHIpe0guUnUocikKcz10
-aGlzLnhiKDApCnJldHVybiBzfX0sClY3OmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmEKaWYoYj09
-bnVsbClzPW51bGwKZWxzZXtzPUgudDYoYikKcz1QLkNIKG5ldyBILmxKKGIscy5DKCJAKDEpIikuYShQ
-LmlHKCkpLHMuQygibEo8MSxAPiIpKSwhMCx0LnopfXJldHVybiBQLmRVKHJbYV0uYXBwbHkocixzKSl9
-LApnaU86ZnVuY3Rpb24oYSl7cmV0dXJuIDB9fQpQLnI3LnByb3RvdHlwZT17fQpQLlR6LnByb3RvdHlw
-ZT17CmNQOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1hPDB8fGE+PXMuZ0EocykKaWYocil0aHJvdyBI
-LmIoUC5URShhLDAscy5nQShzKSxudWxsLG51bGwpKX0sCnE6ZnVuY3Rpb24oYSxiKXtpZihILm9rKGIp
-KXRoaXMuY1AoYikKcmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLlVyKDAsYikpfSwKWTU6ZnVuY3Rpb24o
-YSxiLGMpe3RoaXMuY1AoYikKdGhpcy5iaCgwLGIsYyl9LApnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlz
-LmEubGVuZ3RoCmlmKHR5cGVvZiBzPT09Im51bWJlciImJnM+Pj4wPT09cylyZXR1cm4gcwp0aHJvdyBI
-LmIoUC5QVigiQmFkIEpzQXJyYXkgbGVuZ3RoIikpfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0KUC5j
-by5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIHRoaXMuZTQoMCxiLGMpfX0KUC5u
-ZC5wcm90b3R5cGU9eyRpbmQ6MX0KUC5LZS5wcm90b3R5cGU9ewpEOmZ1bmN0aW9uKCl7dmFyIHMscixx
-LHAsbz10aGlzLmEuZ2V0QXR0cmlidXRlKCJjbGFzcyIpLG49UC5Mcyh0Lk4pCmlmKG89PW51bGwpcmV0
-dXJuIG4KZm9yKHM9by5zcGxpdCgiICIpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Epe3A9Si5UMChzW3Fd
-KQppZihwLmxlbmd0aCE9PTApbi5pKDAscCl9cmV0dXJuIG59LApYOmZ1bmN0aW9uKGEpe3RoaXMuYS5z
-ZXRBdHRyaWJ1dGUoImNsYXNzIixhLmsoMCwiICIpKX19ClAuaGkucHJvdG90eXBlPXsKZ1A6ZnVuY3Rp
-b24oYSl7cmV0dXJuIG5ldyBQLktlKGEpfSwKc2hmOmZ1bmN0aW9uKGEsYil7dGhpcy5ZQyhhLGIpfSwK
-cjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuCmlmKGQ9PW51bGwpe3M9SC5WTShbXSx0
-LnYpCmQ9bmV3IFcudkQocykKQy5ObS5pKHMsVy5UdyhudWxsKSkKQy5ObS5pKHMsVy5CbCgpKQpDLk5t
-LmkocyxuZXcgVy5PdygpKX1jPW5ldyBXLktvKGQpCnI9JzxzdmcgdmVyc2lvbj0iMS4xIj4nK0guRWoo
-YikrIjwvc3ZnPiIKcz1kb2N1bWVudApxPXMuYm9keQpxLnRvU3RyaW5nCnA9Qy5SWS5BSChxLHIsYykK
-bz1zLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpwLnRvU3RyaW5nCnM9bmV3IFcuZTcocCkKbj1zLmdy
-OChzKQpmb3IoO3M9bi5maXJzdENoaWxkLHMhPW51bGw7KW8uYXBwZW5kQ2hpbGQocykKcmV0dXJuIG99
-LApuejpmdW5jdGlvbihhLGIsYyxkLGUpe3Rocm93IEguYihQLkw0KCJDYW5ub3QgaW52b2tlIGluc2Vy
-dEFkamFjZW50SHRtbCBvbiBTVkcuIikpfSwKZ1ZsOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5ldShh
-LCJjbGljayIsITEsdC5rKX0sCiRpaGk6MX0KVS5kMi5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3Zh
-ciBzLHIscSxwLG89dGhpcyxuPXQuWCxtPXQuXyxsPVAuRmwobixtKSxrPW8uYQppZihrIT1udWxsKXtz
-PUguVk0oW10sdC5HKQpmb3Iocj1rLmxlbmd0aCxxPTA7cTxrLmxlbmd0aDtrLmxlbmd0aD09PXJ8fCgw
-LEgubGspKGspLCsrcSl7cD1rW3FdCnMucHVzaChQLkVGKFsiZGVzY3JpcHRpb24iLHAuYSwiaHJlZiIs
-cC5iXSxuLG0pKX1sLlk1KDAsImVkaXRzIixzKX1sLlk1KDAsImV4cGxhbmF0aW9uIixvLmIpCmwuWTUo
-MCwibGluZSIsby5jKQpsLlk1KDAsImRpc3BsYXlQYXRoIixvLmQpCmwuWTUoMCwidXJpUGF0aCIsby5l
-KQpuPW8uZgppZihuIT1udWxsKXttPUguVk0oW10sdC5HKQpmb3Ioaz1uLmxlbmd0aCxxPTA7cTxuLmxl
-bmd0aDtuLmxlbmd0aD09PWt8fCgwLEgubGspKG4pLCsrcSltLnB1c2gobltxXS5MdCgpKQpsLlk1KDAs
-InRyYWNlcyIsbSl9cmV0dXJuIGx9fQpVLlNlLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJu
-IFAuRUYoWyJkZXNjcmlwdGlvbiIsdGhpcy5hLCJocmVmIix0aGlzLmJdLHQuWCx0Ll8pfX0KVS5NbC5w
-cm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3JldHVybiBQLkVGKFsiaHJlZiIsdGhpcy5hLCJsaW5lIix0
-aGlzLmIsInBhdGgiLHRoaXMuY10sdC5YLHQuXyl9fQpVLnlELnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9u
-KCl7dmFyIHMscixxLHA9SC5WTShbXSx0LkcpCmZvcihzPXRoaXMuYixyPXMubGVuZ3RoLHE9MDtxPHMu
-bGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytxKXAucHVzaChzW3FdLkx0KCkpCnJldHVy
-biBQLkVGKFsiZGVzY3JpcHRpb24iLHRoaXMuYSwiZW50cmllcyIscF0sdC5YLHQuXyl9fQpVLndiLnBy
-b3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHA9dGhpcyxvPVAuRmwodC5YLHQuXykKby5Z
-NSgwLCJkZXNjcmlwdGlvbiIscC5hKQpzPXAuYgppZihzIT1udWxsKW8uWTUoMCwiZnVuY3Rpb24iLHMp
-CnM9cC5jCmlmKHMhPW51bGwpby5ZNSgwLCJsaW5rIixzLkx0KCkpCnM9cC5kCmlmKHMubGVuZ3RoIT09
-MCl7cj1ILnQ2KHMpCnE9ci5DKCJsSjwxLFowPHFVKixNaCo+Kj4iKQpvLlk1KDAsImhpbnRBY3Rpb25z
-IixQLlkxKG5ldyBILmxKKHMsci5DKCJaMDxxVSosTWgqPiooMSkiKS5hKG5ldyBVLmIwKCkpLHEpLCEw
-LHEuQygiYUwuRSIpKSl9cmV0dXJuIG99fQpVLmFOLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
-dHVybiBSLm56KHQudC5hKGEpKX0sCiRTOjM4fQpVLmIwLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
-e3JldHVybiB0LmFYLmEoYSkuTHQoKX0sCiRTOjM5fQpCLmo4LnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9u
-KCl7cmV0dXJuIFAuRUYoWyJsaW5lIix0aGlzLmEsImV4cGxhbmF0aW9uIix0aGlzLmIsIm9mZnNldCIs
-dGhpcy5jXSx0LlgsdC5fKX19CkIucXAucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEs
-cCxvLG4sbSxsPXRoaXMsaz10Llgsaj1QLkZsKGssdC5kcCkKZm9yKHM9bC5kLHM9cy5nUHUocykscz1z
-LmdtKHMpLHI9dC5fLHE9dC5HO3MuRigpOyl7cD1zLmdsKCkKbz1wLmEKbj1ILlZNKFtdLHEpCmZvcihw
-PUouSVQocC5iKTtwLkYoKTspe209cC5nbCgpCm4ucHVzaChQLkVGKFsibGluZSIsbS5hLCJleHBsYW5h
-dGlvbiIsbS5iLCJvZmZzZXQiLG0uY10sayxyKSl9ai5ZNSgwLG8sbil9cmV0dXJuIFAuRUYoWyJyZWdp
-b25zIixsLmEsIm5hdmlnYXRpb25Db250ZW50IixsLmIsInNvdXJjZUNvZGUiLGwuYywiZWRpdHMiLGpd
-LGsscil9fQpULm1RLnByb3RvdHlwZT17fQpMLmUucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFy
-IHMscixxLHAsbyxuLG0KdC5hTC5hKGEpCnM9d2luZG93LmxvY2F0aW9uLnBhdGhuYW1lCnI9TC5HNih3
-aW5kb3cubG9jYXRpb24uaHJlZikKcT1MLmFLKHdpbmRvdy5sb2NhdGlvbi5ocmVmKQpMLkdlKCkKaWYo
-cyE9PSIvIiYmcyE9PUouVDAoZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29udGVu
-dCkpTC5HNyhzLHIscSwhMCxuZXcgTC5WVyhzLHIscSkpCnA9ZG9jdW1lbnQKbz1KLnFGKHAucXVlcnlT
-ZWxlY3RvcigiLmFwcGx5LW1pZ3JhdGlvbiIpKQpuPW8uJHRpCm09bi5DKCJ+KDEpPyIpLmEobmV3IEwu
-b1ooKSkKdC5aLmEobnVsbCkKVy5KRShvLmEsby5iLG0sITEsbi5jKQpuPUoucUYocC5xdWVyeVNlbGVj
-dG9yKCIucmVydW4tbWlncmF0aW9uIikpCm09bi4kdGkKVy5KRShuLmEsbi5iLG0uQygifigxKT8iKS5h
-KG5ldyBMLkhpKCkpLCExLG0uYykKbT1KLnFGKHAucXVlcnlTZWxlY3RvcigiLnJlcG9ydC1wcm9ibGVt
-IikpCm49bS4kdGkKVy5KRShtLmEsbS5iLG4uQygifigxKT8iKS5hKG5ldyBMLkJUKCkpLCExLG4uYykK
-cD1KLnFGKHAucXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUgLmNsb3NlIikpCm49cC4kdGkKVy5KRShw
-LmEscC5iLG4uQygifigxKT8iKS5hKG5ldyBMLlBZKCkpLCExLG4uYykKbj1KLnFGKCQuYzAoKSkKcD1u
-LiR0aQpXLkpFKG4uYSxuLmIscC5DKCJ+KDEpPyIpLmEobmV3IEwudTgoKSksITEscC5jKX0sCiRTOjE5
-fQpMLlZXLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7TC5Gcih0aGlzLmEsdGhpcy5iLHRoaXMuYyl9
-LAokUzoyfQpMLm9aLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8KdC5PLmEo
-YSkKaWYoSC5vVChDLm9sLnVzKHdpbmRvdywiVGhpcyB3aWxsIGFwcGx5IHRoZSBjaGFuZ2VzIHlvdSd2
-ZSBwcmV2aWV3ZWQgdG8geW91ciB3b3JraW5nIGRpcmVjdG9yeS4gSXQgaXMgcmVjb21tZW5kZWQgeW91
-IGNvbW1pdCBhbnkgY2hhbmdlcyB5b3UgbWFkZSBiZWZvcmUgZG9pbmcgdGhpcy4iKSkpe3M9SC5WTShb
-XSx0LkcpCmZvcihyPSQuSVIscT1yLmxlbmd0aCxwPTA7cDxyLmxlbmd0aDtyLmxlbmd0aD09PXF8fCgw
-LEgubGspKHIpLCsrcClzLnB1c2gocltwXS5MdCgpKQpzPUwudHkoIi9hcHBseS1taWdyYXRpb24iLFAu
-RUYoWyJuYXZpZ2F0aW9uVHJlZSIsc10sdC5YLHQuZHApKS5XNyhuZXcgTC5qcigpLHQuUCkKbz1uZXcg
-TC5xbCgpCnQuYjcuYShudWxsKQpyPXMuJHRpCnE9JC5YMwppZihxIT09Qy5OVSlvPVAuVkgobyxxKQpz
-LnhmKG5ldyBQLkZlKG5ldyBQLnZzKHEsciksMixudWxsLG8sci5DKCJAPDE+IikuS3Eoci5jKS5DKCJG
-ZTwxLDI+IikpKX19LAokUzoxfQpMLmpyLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQu
-dC5hKGEpCnM9ZG9jdW1lbnQuYm9keQpzLmNsYXNzTGlzdC5yZW1vdmUoInByb3Bvc2VkIikKcy5jbGFz
-c0xpc3QuYWRkKCJhcHBsaWVkIil9LAokUzo0Mn0KTC5xbC5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihh
-LGIpe0wuQzIoIkNvdWxkbid0IGFwcGx5IG1pZ3JhdGlvbiIsYSxiKX0sCiRDOiIkMiIsCiRSOjIsCiRT
-OjE3fQpMLkhpLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnhuKHQuTy5hKGEp
-KX0sCnhuOmZ1bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuLG0sbCxrLGoK
-dmFyICRhc3luYyQkMT1QLmx6KGZ1bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9YwpzPXF9d2hpbGUodHJ1
-ZSlzd2l0Y2gocyl7Y2FzZSAwOnE9Mwpkb2N1bWVudC5ib2R5LmNsYXNzTGlzdC5hZGQoInJlcnVubmlu
-ZyIpCnM9NgpyZXR1cm4gUC5qUShMLnR5KCIvcmVydW4tbWlncmF0aW9uIixudWxsKSwkYXN5bmMkJDEp
-CmNhc2UgNjpuPWMKaWYoSC5vVChILnk4KEoueDkobiwic3VjY2VzcyIpKSkpd2luZG93LmxvY2F0aW9u
-LnJlbG9hZCgpCmVsc2UgTC5LMCh0LmVFLmEoSi54OShuLCJlcnJvcnMiKSkpCm8ucHVzaCg1KQpzPTQK
-YnJlYWsKY2FzZSAzOnE9MgpqPXAKbT1ILlJ1KGopCmw9SC50cyhqKQpMLkMyKCJGYWlsZWQgdG8gcmVy
-dW4gbWlncmF0aW9uIixtLGwpCm8ucHVzaCg1KQpzPTQKYnJlYWsKY2FzZSAyOm89WzFdCmNhc2UgNDpx
-PTEKZG9jdW1lbnQuYm9keS5jbGFzc0xpc3QucmVtb3ZlKCJyZXJ1bm5pbmciKQpzPW8ucG9wKCkKYnJl
-YWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0
-dXJuIFAuREkoJGFzeW5jJCQxLHIpfSwKJFM6MjB9CkwuQlQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
-YSl7dC5PLmEoYSkKQy5vbC5Qbyh3aW5kb3csUC5YZCgiaHR0cHMiLCJnaXRodWIuY29tIiwiZGFydC1s
-YW5nL3Nkay9pc3N1ZXMvbmV3IixQLkVGKFsidGl0bGUiLCJDdXN0b21lci1yZXBvcnRlZCBpc3N1ZSB3
-aXRoIE5OQkQgbWlncmF0aW9uIHRvb2wiLCJsYWJlbHMiLHUuZCwiYm9keSIsIiMjIyMgU3RlcHMgdG8g
-cmVwcm9kdWNlXG5cbiMjIyMgV2hhdCBkaWQgeW91IGV4cGVjdCB0byBoYXBwZW4/XG5cbiMjIyMgV2hh
-dCBhY3R1YWxseSBoYXBwZW5lZD9cblxuX1NjcmVlbnNob3RzIGFyZSBhcHByZWNpYXRlZF9cblxuKipE
-YXJ0IFNESyB2ZXJzaW9uKio6ICIrSC5Faihkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2RrLXZlcnNp
-b24iKS50ZXh0Q29udGVudCkrIlxuXG5UaGFua3MgZm9yIGZpbGluZyFcbiJdLHQuWCx0LnopKS5nbkQo
-KSwicmVwb3J0LXByb2JsZW0iKX0sCiRTOjF9CkwuUFkucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7
-dmFyIHMKdC5PLmEoYSkKcz1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIpLnN0eWxl
-CnMuZGlzcGxheT0ibm9uZSIKcmV0dXJuIm5vbmUifSwKJFM6NDR9CkwudTgucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAKdC5PLmEoYSkKcz0kLkQ5KCkuaW5uZXJUZXh0CnI9dC5nLmEo
-ZG9jdW1lbnQucXVlcnlTZWxlY3RvcignLm5hdi1wYW5lbCBbZGF0YS1uYW1lKj0iJytILkVqKFcuTGoo
-cykpKyciXScpLnBhcmVudE5vZGUpCnE9ci5xdWVyeVNlbGVjdG9yKCIuc3RhdHVzLWljb24iKQpwPUwu
-eXcoJC5JUixzKQppZihwIGluc3RhbmNlb2YgTC5jRCYmSC5vVChwLngpKXtMLk90KHApCkwueG4ocSxw
-KQpMLkFSKHIscCl9fSwKJFM6MX0KTC5MLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cQp0LmFMLmEoYSkKcz13aW5kb3cubG9jYXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlv
-bi5ocmVmKQpxPUwuYUsod2luZG93LmxvY2F0aW9uLmhyZWYpCmlmKHMubGVuZ3RoPjEpTC5HNyhzLHIs
-cSwhMSxudWxsKQplbHNle0wuQkUocyxCLndSKCksITApCkwuQlgoIiZuYnNwOyIsbnVsbCl9fSwKJFM6
-MTl9CkwuV3gucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbz0iY29sbGFwc2Vk
-Igp0Lk8uYShhKQpzPXRoaXMuYQpyPUouWUUocykKcT10aGlzLmIKcD1KLllFKHEpCmlmKCFyLmdQKHMp
-LnRnKDAsbykpe3IuZ1AocykuaSgwLG8pCnAuZ1AocSkuaSgwLG8pfWVsc2V7ci5nUChzKS5SKDAsbykK
-cC5nUChxKS5SKDAsbyl9fSwKJFM6MX0KTC5BTy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIg
-cz1KLnFGKHQuZy5hKGEpKSxyPXMuJHRpLHE9ci5DKCJ+KDEpPyIpLmEobmV3IEwuZE4odGhpcy5hKSkK
-dC5aLmEobnVsbCkKVy5KRShzLmEscy5iLHEsITEsci5jKX0sCiRTOjN9CkwuZE4ucHJvdG90eXBlPXsK
-JDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEwudDIodC5PLmEoYSksdGhpcy5hKX0sCiRTOjZ9CkwuSG8ucHJv
-dG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuZy5hKGEpCnM9Si5xRihhKQpyPXMuJHRp
-CnE9ci5DKCJ+KDEpPyIpLmEobmV3IEwueHooYSx0aGlzLmEpKQp0LlouYShudWxsKQpXLkpFKHMuYSxz
-LmIscSwhMSxyLmMpfSwKJFM6M30KTC54ei5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0
-Lk8uYShhKQpzPXRoaXMuYQpMLmhYKHRoaXMuYixQLlFBKHMuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3
-IFcuU3kobmV3IFcuaTcocykpLk9VKCJvZmZzZXQiKSksbnVsbCksUC5RQShzLmdldEF0dHJpYnV0ZSgi
-ZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5PVSgibGluZSIpKSxudWxsKSl9LAokUzoxfQpMLklD
-LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPUoucUYodC5nLmEoYSkpLHI9cy4kdGkKci5D
-KCJ+KDEpPyIpLmEoTC5pUygpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIsTC5pUygpLCExLHIuYyl9
-LAokUzozfQpMLmZDLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuZVEuYShhKQp0aGlzLmEuYU0o
-MCx0aGlzLmIpfSwKJFM6NDd9CkwuVG0ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7SC5oKGEpCnJl
-dHVybiBhLmxlbmd0aD40MD9KLmxkKGEsMCw0MCkrIi4uLiI6YX0sCiRTOjQ4fQpMLm5ULnByb3RvdHlw
-ZT17CiQwOmZ1bmN0aW9uKCl7TC5Gcih0aGlzLmEsdGhpcy5iLHRoaXMuYyl9LAokUzoyfQpMLk5ZLnBy
-b3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7TC5Gcih0aGlzLmEsbnVsbCxudWxsKX0sCiRTOjJ9CkwudWUu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dC5hdy5hKGEpCnJldHVybiBILkVqKGEucSgwLCJzZXZl
-cml0eSIpKSsiIC0gIitILkVqKGEucSgwLCJtZXNzYWdlIikpKyIgYXQgIitILkVqKGEucSgwLCJsb2Nh
-dGlvbiIpKSsiIC0gKCIrSC5FaihhLnEoMCwiY29kZSIpKSsiKSJ9LAokUzo0OX0KTC5lWC5wcm90b3R5
-cGU9ewokMTpmdW5jdGlvbihhKXt0LmcuYShhKQokLnpCKCkudG9TdHJpbmcKdC5kSC5hKCQub3coKS5x
-KDAsImhsanMiKSkuVjcoImhpZ2hsaWdodEJsb2NrIixbYV0pfSwKJFM6M30KTC5FRS5wcm90b3R5cGU9
-ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyCnQuTy5hKGEpLnByZXZlbnREZWZhdWx0KCkKcz10aGlzLmEK
-cj10aGlzLmIKTC5hZih3aW5kb3cubG9jYXRpb24ucGF0aG5hbWUscyxyLCEwLG5ldyBMLlFMKHMscikp
-CkwuaFgodGhpcy5jLHMscil9LAokUzoxfQpMLlFMLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7TC5G
-cih3aW5kb3cubG9jYXRpb24ucGF0aG5hbWUsdGhpcy5hLHRoaXMuYil9LAokUzoyfQpMLlZTLnByb3Rv
-dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHI9InNlbGVjdGVkLWZpbGUiCnQuZy5hKGEpCmEudG9T
-dHJpbmcKcz1KLllFKGEpCmlmKGEuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTco
-YSkpLk9VKCJuYW1lIikpPT09dGhpcy5hLmEpcy5nUChhKS5pKDAscikKZWxzZSBzLmdQKGEpLlIoMCxy
-KX0sCiRTOjN9CkwuVEQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscgp0Lk8uYShhKQpz
-PXRoaXMuYQpzd2l0Y2gocy5nTCgpKXtjYXNlIEMuY3c6YnJlYWsKY2FzZSBDLldEOnMubkcoKQpicmVh
-awpjYXNlIEMuWGo6cy5jMigpCmJyZWFrCmNhc2UgQy5kYzpzLmMyKCkKYnJlYWt9cj10aGlzLmIKTC5o
-bChyLHMpCkwueG4odGhpcy5jLHMpCkwuQVIocixzKX0sCiRTOjF9CkwuSWYucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7dmFyIHMKdC5PLmEoYSkKcz10aGlzLmEKTC5PdChzKQpMLnhuKHRoaXMuYixzKQpM
-LkFSKHRoaXMuYyxzKX0sCiRTOjF9CkwudEIucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJu
-IEwudDIodC5PLmEoYSksITApfSwKJFM6Nn0KTC5tMi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXty
-ZXR1cm4gdGhpcy5SSSh0Lk8uYShhKSl9LApSSTpmdW5jdGlvbihhKXt2YXIgcz0wLHI9UC5GWCh0LlAp
-LHE9MSxwLG89W10sbj10aGlzLG0sbCxrLGosaSxoLGcsZgp2YXIgJGFzeW5jJCQxPVAubHooZnVuY3Rp
-b24oYixjKXtpZihiPT09MSl7cD1jCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6cT0zCmk9
-ZG9jdW1lbnQKbT1DLkNELnpRKGkucXVlcnlTZWxlY3RvcigiLmNvbnRlbnQiKS5zY3JvbGxUb3ApCmg9
-dC5YCnM9NgpyZXR1cm4gUC5qUShMLnR5KEwuUTQoIi9hcHBseS1oaW50IixQLkZsKGgsaCkpLG4uYS5M
-dCgpKSwkYXN5bmMkJDEpCmNhc2UgNjpoPW4uYgpsPUwuVXMoaC5hKQpzPTcKcmV0dXJuIFAualEoTC5H
-NyhsLG51bGwsaC5iLCExLG51bGwpLCRhc3luYyQkMSkKY2FzZSA3OmkuYm9keS5jbGFzc0xpc3QuYWRk
-KCJuZWVkcy1yZXJ1biIpCmk9aS5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpCmkudG9TdHJpbmcKaS5z
-Y3JvbGxUb3A9Si5WdShtKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKZj1wCms9SC5SdShmKQpqPUgu
-dHMoZikKTC5DMigiY291bGRuJ3QgYXBwbHkgaGludCIsayxqKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpi
-cmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpy
-ZXR1cm4gUC5ESSgkYXN5bmMkJDEscil9LAokUzoyMH0KTC5RVy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9u
-KGEpe3JldHVybiB0aGlzLmErIjpcbiIrdGhpcy5ifSwKJGlSejoxfQpMLlhBLnByb3RvdHlwZT17CkVi
-OmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4hMH0sCmkwOmZ1bmN0aW9uKGEpe3JldHVybiEwfSwKJGlrRjox
-fQpMLnZ0LnByb3RvdHlwZT17CmdMOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzLmQK
-aWYobC5sZW5ndGg9PT0wKXJldHVybiBDLmN3CnM9Qy5ObS5ndEgobCkuZ0woKQpmb3Iocj1sLmxlbmd0
-aCxxPSEwLHA9ITAsbz0wO288bC5sZW5ndGg7bC5sZW5ndGg9PT1yfHwoMCxILmxrKShsKSwrK28pe249
-bFtvXS5nTCgpCmlmKG4hPXMpcz1udWxsCm09biE9PUMuY3cKaWYobSYmbiE9PUMuV0QpcT0hMQppZiht
-JiZuIT09Qy5YailwPSExfWlmKHMhPW51bGwpcmV0dXJuIHMKaWYocSlyZXR1cm4gQy5XRAppZihwKXJl
-dHVybiBDLlhqCnJldHVybiBDLmRjfSwKTFY6ZnVuY3Rpb24oKXt2YXIgcyxyLHE9dGhpcy5kCmlmKHEh
-PW51bGwpZm9yKHM9cS5sZW5ndGgscj0wO3I8czsrK3IpcVtyXS5iPXRoaXN9LApjMjpmdW5jdGlvbigp
-e3ZhciBzLHIscSxwCmZvcihzPXRoaXMuZCxyPXMubGVuZ3RoLHE9MDtxPHMubGVuZ3RoO3MubGVuZ3Ro
-PT09cnx8KDAsSC5saykocyksKytxKXtwPXNbcV0KaWYocCBpbnN0YW5jZW9mIEwudnQpcC5jMigpCmVs
-c2UgaWYocCBpbnN0YW5jZW9mIEwuY0QmJkgub1QocC54KSYmcC5yPT09Qy5YailwLnI9Qy5XRH19LApu
-RzpmdW5jdGlvbigpe3ZhciBzLHIscSxwCmZvcihzPXRoaXMuZCxyPXMubGVuZ3RoLHE9MDtxPHMubGVu
-Z3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytxKXtwPXNbcV0KaWYocCBpbnN0YW5jZW9mIEwu
-dnQpcC5uRygpCmVsc2UgaWYocCBpbnN0YW5jZW9mIEwuY0QmJkgub1QocC54KSYmcC5yPT09Qy5XRClw
-LnI9Qy5Yan19LApMdDpmdW5jdGlvbigpe3ZhciBzLHI9UC5GbCh0LlgsdC5fKQpyLlk1KDAsInR5cGUi
-LCJkaXJlY3RvcnkiKQpyLlk1KDAsIm5hbWUiLHRoaXMuYSkKci5ZNSgwLCJzdWJ0cmVlIixMLlZEKHRo
-aXMuZCkpCnM9dGhpcy5jCmlmKHMhPW51bGwpci5ZNSgwLCJwYXRoIixzKQpyZXR1cm4gcn19CkwuY0Qu
-cHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1QLkZsKHQuWCx0Ll8pCnEuWTUo
-MCwidHlwZSIsImZpbGUiKQpxLlk1KDAsIm5hbWUiLHIuYSkKcz1yLmMKaWYocyE9bnVsbClxLlk1KDAs
-InBhdGgiLHMpCnM9ci5kCmlmKHMhPW51bGwpcS5ZNSgwLCJocmVmIixzKQpzPXIuZQppZihzIT1udWxs
-KXEuWTUoMCwiZWRpdENvdW50IixzKQpzPXIuZgppZihzIT1udWxsKXEuWTUoMCwid2FzRXhwbGljaXRs
-eU9wdGVkT3V0IixzKQpzPXIucgppZihzIT1udWxsKXEuWTUoMCwibWlncmF0aW9uU3RhdHVzIixzLmEp
-CnM9ci54CmlmKHMhPW51bGwpcS5ZNSgwLCJtaWdyYXRpb25TdGF0dXNDYW5CZUNoYW5nZWQiLHMpCnJl
-dHVybiBxfSwKZ0w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yfX0KTC5EOC5wcm90b3R5cGU9e30KTC5P
-OS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmJ9fQpMLkdiLnByb3RvdHlwZT17
-Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYn19ClIuTEwucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24o
-KXtyZXR1cm4gUC5FRihbIm5vZGVJZCIsdGhpcy5iLCJraW5kIix0aGlzLmEuYV0sdC5YLHQuXyl9fQpS
-Lk1ELnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0LmZFLmEoYSkuYT09PXRoaXMuYS5x
-KDAsImtpbmQiKX0sCiRTOjUwfQpSLkg3LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
-aXMuYn19Ck0ubEkucHJvdG90eXBlPXsKV086ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9dC5kNApNLllG
-KCJhYnNvbHV0ZSIsSC5WTShbYixudWxsLG51bGwsbnVsbCxudWxsLG51bGwsbnVsbF0scSkpCnM9dGhp
-cy5hCnM9cy5ZcihiKT4wJiYhcy5oSyhiKQppZihzKXJldHVybiBiCnM9RC5hYigpCnI9SC5WTShbcyxi
-LG51bGwsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsXSxxKQpNLllGKCJqb2luIixyKQpyZXR1cm4gdGhp
-cy5JUChuZXcgSC51NihyLHQuZUopKX0sCnpmOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT1YLkNMKGEsdGhp
-cy5hKQpxLkl4KCkKcz1xLmQKcj1zLmxlbmd0aAppZihyPT09MCl7cz1xLmIKcmV0dXJuIHM9PW51bGw/
-Ii4iOnN9aWYocj09PTEpe3M9cS5iCnJldHVybiBzPT1udWxsPyIuIjpzfWlmKDA+PXIpcmV0dXJuIEgu
-T0gocywtMSkKcy5wb3AoKQpzPXEuZQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBv
-cCgpCnEuSXgoKQpyZXR1cm4gcS53KDApfSwKSVA6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0s
-bCxrLGoKdC5RLmEoYSkKZm9yKHM9YS4kdGkscj1zLkMoImEyKGNYLkUpIikuYShuZXcgTS5xNygpKSxx
-PWEuZ20oYSkscz1uZXcgSC5TTyhxLHIscy5DKCJTTzxjWC5FPiIpKSxyPXRoaXMuYSxwPSExLG89ITEs
-bj0iIjtzLkYoKTspe209cS5nbCgpCmlmKHIuaEsobSkmJm8pe2w9WC5DTChtLHIpCms9bi5jaGFyQ29k
-ZUF0KDApPT0wP246bgpuPUMueEIuTmooaywwLHIuU3AoaywhMCkpCmwuYj1uCmlmKHIuZHMobikpQy5O
-bS5ZNShsLmUsMCxyLmdtSSgpKQpuPWwudygwKX1lbHNlIGlmKHIuWXIobSk+MCl7bz0hci5oSyhtKQpu
-PUguRWoobSl9ZWxzZXtqPW0ubGVuZ3RoCmlmKGohPT0wKXtpZigwPj1qKXJldHVybiBILk9IKG0sMCkK
-aj1yLlVkKG1bMF0pfWVsc2Ugaj0hMQppZighailpZihwKW4rPXIuZ21JKCkKbis9bX1wPXIuZHMobSl9
-cmV0dXJuIG4uY2hhckNvZGVBdCgwKT09MD9uOm59LApvNTpmdW5jdGlvbihhKXt2YXIgcwppZighdGhp
-cy55MyhhKSlyZXR1cm4gYQpzPVguQ0woYSx0aGlzLmEpCnMuclIoKQpyZXR1cm4gcy53KDApfSwKeTM6
-ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGoKYS50b1N0cmluZwpzPXRoaXMuYQpyPXMu
-WXIoYSkKaWYociE9PTApe2lmKHM9PT0kLktrKCkpZm9yKHE9MDtxPHI7KytxKWlmKEMueEIuVyhhLHEp
-PT09NDcpcmV0dXJuITAKcD1yCm89NDd9ZWxzZXtwPTAKbz1udWxsfWZvcihuPW5ldyBILnFqKGEpLmEs
-bT1uLmxlbmd0aCxxPXAsbD1udWxsO3E8bTsrK3EsbD1vLG89ayl7az1DLnhCLk8obixxKQppZihzLnI0
-KGspKXtpZihzPT09JC5LaygpJiZrPT09NDcpcmV0dXJuITAKaWYobyE9bnVsbCYmcy5yNChvKSlyZXR1
-cm4hMAppZihvPT09NDYpaj1sPT1udWxsfHxsPT09NDZ8fHMucjQobCkKZWxzZSBqPSExCmlmKGopcmV0
-dXJuITB9fWlmKG89PW51bGwpcmV0dXJuITAKaWYocy5yNChvKSlyZXR1cm4hMAppZihvPT09NDYpcz1s
-PT1udWxsfHxzLnI0KGwpfHxsPT09NDYKZWxzZSBzPSExCmlmKHMpcmV0dXJuITAKcmV0dXJuITF9LApI
-UDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcyxrPSdVbmFibGUgdG8gZmluZCBh
-IHBhdGggdG8gIicKYj1sLldPKDAsYikKcz1sLmEKaWYocy5ZcihiKTw9MCYmcy5ZcihhKT4wKXJldHVy
-biBsLm81KGEpCmlmKHMuWXIoYSk8PTB8fHMuaEsoYSkpYT1sLldPKDAsYSkKaWYocy5ZcihhKTw9MCYm
-cy5ZcihiKT4wKXRocm93IEguYihYLkk3KGsrSC5FaihhKSsnIiBmcm9tICInK0guRWooYikrJyIuJykp
-CnI9WC5DTChiLHMpCnIuclIoKQpxPVguQ0woYSxzKQpxLnJSKCkKcD1yLmQKbz1wLmxlbmd0aAppZihv
-IT09MCl7aWYoMD49bylyZXR1cm4gSC5PSChwLDApCnA9Si5STShwWzBdLCIuIil9ZWxzZSBwPSExCmlm
-KHApcmV0dXJuIHEudygwKQpwPXIuYgpvPXEuYgppZihwIT1vKXA9cD09bnVsbHx8bz09bnVsbHx8IXMu
-TmMocCxvKQplbHNlIHA9ITEKaWYocClyZXR1cm4gcS53KDApCndoaWxlKCEwKXtwPXIuZApvPXAubGVu
-Z3RoCmlmKG8hPT0wKXtuPXEuZAptPW4ubGVuZ3RoCmlmKG0hPT0wKXtpZigwPj1vKXJldHVybiBILk9I
-KHAsMCkKcD1wWzBdCmlmKDA+PW0pcmV0dXJuIEguT0gobiwwKQpuPXMuTmMocCxuWzBdKQpwPW59ZWxz
-ZSBwPSExfWVsc2UgcD0hMQppZighcClicmVhawpDLk5tLlc0KHIuZCwwKQpDLk5tLlc0KHIuZSwxKQpD
-Lk5tLlc0KHEuZCwwKQpDLk5tLlc0KHEuZSwxKX1wPXIuZApvPXAubGVuZ3RoCmlmKG8hPT0wKXtpZigw
-Pj1vKXJldHVybiBILk9IKHAsMCkKcD1KLlJNKHBbMF0sIi4uIil9ZWxzZSBwPSExCmlmKHApdGhyb3cg
-SC5iKFguSTcoaytILkVqKGEpKyciIGZyb20gIicrSC5FaihiKSsnIi4nKSkKcD10Lk4KQy5ObS5VRyhx
-LmQsMCxQLk84KHIuZC5sZW5ndGgsIi4uIiwhMSxwKSkKQy5ObS5ZNShxLmUsMCwiIikKQy5ObS5VRyhx
-LmUsMSxQLk84KHIuZC5sZW5ndGgscy5nbUkoKSwhMSxwKSkKcz1xLmQKcD1zLmxlbmd0aAppZihwPT09
-MClyZXR1cm4iLiIKaWYocD4xJiZKLlJNKEMuTm0uZ3JaKHMpLCIuIikpe3M9cS5kCmlmKDA+PXMubGVu
-Z3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcz1xLmUKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEgu
-T0gocywtMSkKcy5wb3AoKQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCkMu
-Tm0uaShzLCIiKX1xLmI9IiIKcS5JeCgpCnJldHVybiBxLncoMCl9fQpNLnE3LnByb3RvdHlwZT17CiQx
-OmZ1bmN0aW9uKGEpe3JldHVybiBILmgoYSkhPT0iIn0sCiRTOjd9Ck0uTm8ucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7SC5rKGEpCnJldHVybiBhPT1udWxsPyJudWxsIjonIicrYSsnIid9LAokUzo1MX0K
-Qi5mdi5wcm90b3R5cGU9ewp4WjpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuWXIoYSkKaWYocj4wKXJl
-dHVybiBKLmxkKGEsMCxyKQppZih0aGlzLmhLKGEpKXtpZigwPj1hLmxlbmd0aClyZXR1cm4gSC5PSChh
-LDApCnM9YVswXX1lbHNlIHM9bnVsbApyZXR1cm4gc30sCk5jOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGE9
-PWJ9fQpYLldELnByb3RvdHlwZT17Ckl4OmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMKd2hpbGUoITAp
-e3M9cS5kCmlmKCEocy5sZW5ndGghPT0wJiZKLlJNKEMuTm0uZ3JaKHMpLCIiKSkpYnJlYWsKcz1xLmQK
-aWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpzPXEuZQppZigwPj1zLmxlbmd0
-aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpfXM9cS5lCnI9cy5sZW5ndGgKaWYociE9PTApQy5ObS5Z
-NShzLHItMSwiIil9LApyUjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMsbD1ILlZNKFtd
-LHQucykKZm9yKHM9bS5kLHI9cy5sZW5ndGgscT0wLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8
-KDAsSC5saykocyksKytwKXtvPXNbcF0Kbj1KLmlhKG8pCmlmKCEobi5ETihvLCIuIil8fG4uRE4obywi
-IikpKWlmKG4uRE4obywiLi4iKSl7bj1sLmxlbmd0aAppZihuIT09MCl7aWYoMD49bilyZXR1cm4gSC5P
-SChsLC0xKQpsLnBvcCgpfWVsc2UgKytxfWVsc2UgQy5ObS5pKGwsbyl9aWYobS5iPT1udWxsKUMuTm0u
-VUcobCwwLFAuTzgocSwiLi4iLCExLHQuTikpCmlmKGwubGVuZ3RoPT09MCYmbS5iPT1udWxsKUMuTm0u
-aShsLCIuIikKbS5zbkoobCkKcz1tLmEKbS5zUGgoUC5POChsLmxlbmd0aCsxLHMuZ21JKCksITAsdC5O
-KSkKcj1tLmIKaWYocj09bnVsbHx8bC5sZW5ndGg9PT0wfHwhcy5kcyhyKSlDLk5tLlk1KG0uZSwwLCIi
-KQpyPW0uYgppZihyIT1udWxsJiZzPT09JC5LaygpKXtyLnRvU3RyaW5nCm0uYj1ILnlzKHIsIi8iLCJc
-XCIpfW0uSXgoKX0sCnc6ZnVuY3Rpb24oYSl7dmFyIHMscixxPXRoaXMscD1xLmIKcD1wIT1udWxsP3A6
-IiIKZm9yKHM9MDtzPHEuZC5sZW5ndGg7KytzKXtyPXEuZQppZihzPj1yLmxlbmd0aClyZXR1cm4gSC5P
-SChyLHMpCnI9cCtILkVqKHJbc10pCnA9cS5kCmlmKHM+PXAubGVuZ3RoKXJldHVybiBILk9IKHAscykK
-cD1yK0guRWoocFtzXSl9cCs9SC5FaihDLk5tLmdyWihxLmUpKQpyZXR1cm4gcC5jaGFyQ29kZUF0KDAp
-PT0wP3A6cH0sCnNuSjpmdW5jdGlvbihhKXt0aGlzLmQ9dC5ELmEoYSl9LApzUGg6ZnVuY3Rpb24oYSl7
-dGhpcy5lPXQuRC5hKGEpfX0KWC5kdi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJQYXRo
-RXhjZXB0aW9uOiAiK3RoaXMuYX0sCiRpUno6MX0KTy56TC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEp
-e3JldHVybiB0aGlzLmdvYyh0aGlzKX19CkUuT0YucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7cmV0
-dXJuIEMueEIudGcoYSwiLyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N30sCmRzOmZ1bmN0
-aW9uKGEpe3ZhciBzPWEubGVuZ3RoCnJldHVybiBzIT09MCYmQy54Qi5PKGEscy0xKSE9PTQ3fSwKU3A6
-ZnVuY3Rpb24oYSxiKXtpZihhLmxlbmd0aCE9PTAmJkMueEIuVyhhLDApPT09NDcpcmV0dXJuIDEKcmV0
-dXJuIDB9LApZcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEp
-e3JldHVybiExfSwKZ29jOmZ1bmN0aW9uKCl7cmV0dXJuInBvc2l4In0sCmdtSTpmdW5jdGlvbigpe3Jl
-dHVybiIvIn19CkYucnUucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7cmV0dXJuIEMueEIudGcoYSwi
-LyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N30sCmRzOmZ1bmN0aW9uKGEpe3ZhciBzPWEu
-bGVuZ3RoCmlmKHM9PT0wKXJldHVybiExCmlmKEMueEIuTyhhLHMtMSkhPT00NylyZXR1cm4hMApyZXR1
-cm4gQy54Qi5UYyhhLCI6Ly8iKSYmdGhpcy5ZcihhKT09PXN9LApTcDpmdW5jdGlvbihhLGIpe3ZhciBz
-LHIscSxwLG89YS5sZW5ndGgKaWYobz09PTApcmV0dXJuIDAKaWYoQy54Qi5XKGEsMCk9PT00NylyZXR1
-cm4gMQpmb3Iocz0wO3M8bzsrK3Mpe3I9Qy54Qi5XKGEscykKaWYocj09PTQ3KXJldHVybiAwCmlmKHI9
-PT01OCl7aWYocz09PTApcmV0dXJuIDAKcT1DLnhCLlhVKGEsIi8iLEMueEIuUWkoYSwiLy8iLHMrMSk/
-cyszOnMpCmlmKHE8PTApcmV0dXJuIG8KaWYoIWJ8fG88cSszKXJldHVybiBxCmlmKCFDLnhCLm5DKGEs
-ImZpbGU6Ly8iKSlyZXR1cm4gcQppZighQi5ZdShhLHErMSkpcmV0dXJuIHEKcD1xKzMKcmV0dXJuIG89
-PT1wP3A6cSs0fX1yZXR1cm4gMH0sCllyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlNwKGEsITEpfSwK
-aEs6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RoIT09MCYmQy54Qi5XKGEsMCk9PT00N30sCmdvYzpm
-dW5jdGlvbigpe3JldHVybiJ1cmwifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJuIi8ifX0KTC5JVi5wcm90
-b3R5cGU9ewpVZDpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihh
-KXtyZXR1cm4gYT09PTQ3fHxhPT09OTJ9LApkczpmdW5jdGlvbihhKXt2YXIgcz1hLmxlbmd0aAppZihz
-PT09MClyZXR1cm4hMQpzPUMueEIuTyhhLHMtMSkKcmV0dXJuIShzPT09NDd8fHM9PT05Mil9LApTcDpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIscT1hLmxlbmd0aAppZihxPT09MClyZXR1cm4gMApzPUMueEIuVyhh
-LDApCmlmKHM9PT00NylyZXR1cm4gMQppZihzPT09OTIpe2lmKHE8Mnx8Qy54Qi5XKGEsMSkhPT05Mily
-ZXR1cm4gMQpyPUMueEIuWFUoYSwiXFwiLDIpCmlmKHI+MCl7cj1DLnhCLlhVKGEsIlxcIixyKzEpCmlm
-KHI+MClyZXR1cm4gcn1yZXR1cm4gcX1pZihxPDMpcmV0dXJuIDAKaWYoIUIuT1MocykpcmV0dXJuIDAK
-aWYoQy54Qi5XKGEsMSkhPT01OClyZXR1cm4gMApxPUMueEIuVyhhLDIpCmlmKCEocT09PTQ3fHxxPT09
-OTIpKXJldHVybiAwCnJldHVybiAzfSwKWXI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuU3AoYSwhMSl9
-LApoSzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ZcihhKT09PTF9LApPdDpmdW5jdGlvbihhLGIpe3Zh
-ciBzCmlmKGE9PT1iKXJldHVybiEwCmlmKGE9PT00NylyZXR1cm4gYj09PTkyCmlmKGE9PT05MilyZXR1
-cm4gYj09PTQ3CmlmKChhXmIpIT09MzIpcmV0dXJuITEKcz1hfDMyCnJldHVybiBzPj05NyYmczw9MTIy
-fSwKTmM6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYoYT09YilyZXR1cm4hMApzPWEubGVuZ3RoCmlm
-KHMhPT1iLmxlbmd0aClyZXR1cm4hMQpmb3Iocj1KLnJZKGIpLHE9MDtxPHM7KytxKWlmKCF0aGlzLk90
-KEMueEIuVyhhLHEpLHIuVyhiLHEpKSlyZXR1cm4hMQpyZXR1cm4hMH0sCmdvYzpmdW5jdGlvbigpe3Jl
-dHVybiJ3aW5kb3dzIn0sCmdtSTpmdW5jdGlvbigpe3JldHVybiJcXCJ9fTsoZnVuY3Rpb24gYWxpYXNl
-cygpe3ZhciBzPUouR3YucHJvdG90eXBlCnMuVT1zLncKcy5Taj1zLmU3CnM9Si5NRi5wcm90b3R5cGUK
-cy50PXMudwpzPVAuY1gucHJvdG90eXBlCnMuR0c9cy5ldgpzPVAuTWgucHJvdG90eXBlCnMueGI9cy53
-CnM9Vy5jdi5wcm90b3R5cGUKcy5EVz1zLnI2CnM9Vy5tNi5wcm90b3R5cGUKcy5qRj1zLkViCnM9UC5F
-NC5wcm90b3R5cGUKcy5Vcj1zLnEKcy5lND1zLlk1CnM9UC5jby5wcm90b3R5cGUKcy5iaD1zLlk1fSko
-KTsoZnVuY3Rpb24gaW5zdGFsbFRlYXJPZmZzKCl7dmFyIHM9aHVua0hlbHBlcnMuX3N0YXRpY18xLHI9
-aHVua0hlbHBlcnMuX3N0YXRpY18wLHE9aHVua0hlbHBlcnMuaW5zdGFsbEluc3RhbmNlVGVhck9mZixw
-PWh1bmtIZWxwZXJzLmluc3RhbGxTdGF0aWNUZWFyT2ZmLG89aHVua0hlbHBlcnMuX2luc3RhbmNlXzF1
-CnMoUCwiRVgiLCJaViIsOCkKcyhQLCJ5dCIsIm9BIiw4KQpzKFAsInFXIiwiQnoiLDgpCnIoUCwiVUki
-LCJlTiIsMCkKcShQLlBmLnByb3RvdHlwZSwiZ1lKIiwwLDEsbnVsbCxbIiQyIiwiJDEiXSxbIncwIiwi
-cG0iXSwyNiwwKQpzKFAsIkN5IiwiTkMiLDQpCnMoUCwiUEgiLCJNdCIsNSkKcChXLCJwUyIsNCxudWxs
-LFsiJDQiXSxbInFEIl0sOSwwKQpwKFcsIlY0Iiw0LG51bGwsWyIkNCJdLFsibloiXSw5LDApCm8oUC5B
-cy5wcm90b3R5cGUsImd1TSIsIlYiLDUpCnMoUCwiaUciLCJ3WSIsNTQpCnMoUCwidzAiLCJkVSIsMzYp
-CnMoTCwiaVMiLCJpNiIsNil9KSgpOyhmdW5jdGlvbiBpbmhlcml0YW5jZSgpe3ZhciBzPWh1bmtIZWxw
-ZXJzLm1peGluLHI9aHVua0hlbHBlcnMuaW5oZXJpdCxxPWh1bmtIZWxwZXJzLmluaGVyaXRNYW55CnIo
-UC5NaCxudWxsKQpxKFAuTWgsW0guRkssSi5HdixKLm0xLFAuY1gsSC5FNyxQLlhTLFAublksSC5hNyxQ
-LkFuLEguRnUsSC5KQixILlNVLEguUmUsSC53dixQLlBuLEguV1UsSC5MSSxILlRwLEguZjksSC50ZSxI
-LmJxLEguWE8sSC5rcixQLllrLEgudmgsSC5ONixILlZSLEguRUssSC5QYixILnRRLEguU2QsSC5KYyxI
-LkcsSC5sWSxQLlczLFAuaWgsUC5GeSxQLkdWLFAuQ3csUC5QZixQLkZlLFAudnMsUC5PTSxQLnFoLFAu
-TU8sUC5rVCxQLnhJLFAubTAsUC5wUixQLmJuLFAubG0sUC5sRCxQLktQLFAubGYsUC5XWSxQLlVrLFAu
-U2gsUC5SdyxQLmJ6LFAuaVAsUC5rNSxQLktZLFAuQ0QsUC5hRSxQLk4zLFAuYzgsUC5aZCxQLlJuLFAu
-RG4sUC5QRSxQLlVmLFcuaWQsVy5GayxXLkpRLFcuR20sVy52RCxXLm02LFcuT3csVy5XOSxXLmRXLFcu
-bWssVy5LbyxQLmlKLFAuRTQsVS5kMixVLlNlLFUuTWwsVS55RCxVLndiLEIuajgsQi5xcCxULm1RLEwu
-WEEsTC5EOCxMLk85LEwuR2IsUi5MTCxSLkg3LE0ubEksTy56TCxYLldELFguZHZdKQpxKEouR3YsW0ou
-eUUsSi53ZSxKLk1GLEouamQsSi5xSSxKLkRyLEguRVQsVy5EMCxXLkF6LFcuTGUsVy5OaCxXLmFlLFcu
-SUIsVy5uNyxXLmVhLFcuYnIsVy5TZyxXLnc3LFcuSzcsVy5YVyxQLmhGXSkKcShKLk1GLFtKLmlDLEou
-a2QsSi5jNV0pCnIoSi5QbyxKLmpkKQpxKEoucUksW0ouYlUsSi5rRF0pCnEoUC5jWCxbSC5CUixILmJR
-LEguaTEsSC5VNSxILkFNLEgudTYsSC5YUixQLm1XLEgudW5dKQpxKEguQlIsW0guWnksSC5RQ10pCnIo
-SC5vbCxILlp5KQpyKEguVXEsSC5RQykKcihILmpWLEguVXEpCnEoUC5YUyxbSC5uLEgucjMsSC5HTSxQ
-LkV6LEguYXosSC52VixILkVxLFAuQzYsSC5rUyxQLlVkLFAuRixQLnUsUC5tcCxQLnViLFAuZHMsUC5s
-aixQLlVWLFAuYyxMLlFXXSkKcihQLnV5LFAublkpCnEoUC51eSxbSC53MixXLnd6LFcuZTddKQpyKEgu
-cWosSC53MikKcShILmJRLFtILmFMLEguTUIsSC5pNV0pCnEoSC5hTCxbSC5uSCxILmxKLFAuaThdKQpy
-KEgueHksSC5pMSkKcShQLkFuLFtILk1ILEguU08sSC5VMV0pCnIoSC5kNSxILkFNKQpyKFAuUlUsUC5Q
-bikKcihQLkdqLFAuUlUpCnIoSC5QRCxQLkdqKQpyKEguTFAsSC5XVSkKcShILlRwLFtILkNqLEgubGMs
-SC5kQyxILndOLEguVlgsUC50aCxQLmhhLFAuVnMsUC5GdCxQLnlILFAuV00sUC5TWCxQLkdzLFAuZGEs
-UC5vUSxQLnBWLFAuVTcsUC52cixQLnJ0LFAuS0YsUC5aTCxQLlJULFAualosUC5ycSxQLlJXLFAuQjUs
-UC51TyxQLnBLLFAuVnAsUC5PUixQLnJhLFAueVEsUC54cixQLk56LFAudGksUC5XRixQLm4xLFAuY1Ms
-UC5WQyxQLkpULFAuUlosUC5NRSxQLnk1LFAueUksUC5jNixQLnFkLFcuQ3YsVy5LUyxXLkEzLFcudk4s
-Vy5VdixXLkVnLFcuRW8sVy5XayxXLklBLFcuZm0sUC5qZyxQLlRhLFAuR0UsUC5ONyxQLnVRLFAuUEMs
-UC5tdCxQLlFTLFAubnAsUC5VdCxVLmFOLFUuYjAsTC5lLEwuVlcsTC5vWixMLmpyLEwucWwsTC5IaSxM
-LkJULEwuUFksTC51OCxMLkwsTC5XeCxMLkFPLEwuZE4sTC5IbyxMLnh6LEwuSUMsTC5mQyxMLlRtLEwu
-blQsTC5OWSxMLnVlLEwuZVgsTC5FRSxMLlFMLEwuVlMsTC5URCxMLklmLEwudEIsTC5tMixSLk1ELE0u
-cTcsTS5Ob10pCnIoSC5XMCxQLkV6KQpxKEgubGMsW0guengsSC5yVF0pCnIoSC5rWSxQLkM2KQpyKFAu
-aWwsUC5ZaykKcShQLmlsLFtILk41LFAudXcsVy5jZixXLlN5XSkKcShQLm1XLFtILktXLFAucTRdKQpy
-KEguTFosSC5FVCkKcShILkxaLFtILlJHLEguV0JdKQpyKEguVlAsSC5SRykKcihILkRnLEguVlApCnIo
-SC5aRyxILldCKQpyKEguUGcsSC5aRykKcShILlBnLFtILnhqLEguZEUsSC5aQSxILmRULEguUHEsSC5l
-RSxILlY2XSkKcihILmlNLEgua1MpCnIoUC5aZixQLlBmKQpyKFAuSmksUC5tMCkKcihQLlh2LFAucFIp
-CnIoUC5iNixQLlh2KQpyKFAuVmosUC5XWSkKcShQLlVrLFtQLkNWLFAuWmksUC5ieV0pCnIoUC53SSxQ
-LmtUKQpxKFAud0ksW1AuVTgsUC5vaixQLk14LFAuRTMsUC5HWV0pCnIoUC5LOCxQLlVkKQpyKFAudHUs
-UC5TaCkKcihQLnU1LFAuWmkpCnEoUC51LFtQLmJKLFAuZVldKQpyKFAucWUsUC5EbikKcShXLkQwLFtX
-LnVILFcud2EsVy5LNSxXLkNtXSkKcShXLnVILFtXLmN2LFcubngsVy5RRixXLkNRXSkKcShXLmN2LFtX
-LnFFLFAuaGldKQpxKFcucUUsW1cuR2gsVy5mWSxXLm5CLFcuUVAsVy5oNCxXLlNOLFcubHAsVy5UYixX
-Lkl2LFcuV1AsVy55WV0pCnIoVy5vSixXLkxlKQpyKFcuaEgsVy5BeikKcihXLlZiLFcuUUYpCnIoVy5m
-SixXLndhKQpxKFcuZWEsW1cudzYsVy5ld10pCnIoVy5BaixXLnc2KQpyKFcuckIsVy5LNykKcihXLkJI
-LFcuckIpCnIoVy53NCxXLklCKQpyKFcub2EsVy5YVykKcihXLnJoLFcub2EpCnIoVy5pNyxXLmNmKQpy
-KFAuQXMsUC5WaikKcShQLkFzLFtXLkk0LFAuS2VdKQpyKFcuUk8sUC5xaCkKcihXLmV1LFcuUk8pCnIo
-Vy54QyxQLk1PKQpyKFcuY3QsVy5tNikKcihQLkJmLFAuaUopCnEoUC5FNCxbUC5yNyxQLmNvXSkKcihQ
-LlR6LFAuY28pCnIoUC5uZCxQLmhpKQpxKEwuRDgsW0wudnQsTC5jRF0pCnIoQi5mdixPLnpMKQpxKEIu
-ZnYsW0UuT0YsRi5ydSxMLklWXSkKcyhILncyLEguUmUpCnMoSC5RQyxQLmxEKQpzKEguUkcsUC5sRCkK
-cyhILlZQLEguU1UpCnMoSC5XQixQLmxEKQpzKEguWkcsSC5TVSkKcyhQLm5ZLFAubEQpCnMoUC5XWSxQ
-LmxmKQpzKFAuUlUsUC5LUCkKcyhQLnBSLFAubGYpCnMoVy5MZSxXLmlkKQpzKFcuSzcsUC5sRCkKcyhX
-LnJCLFcuR20pCnMoVy5YVyxQLmxEKQpzKFcub2EsVy5HbSkKcyhQLmNvLFAubEQpfSkoKQp2YXIgdj17
-dHlwZVVuaXZlcnNlOntlQzpuZXcgTWFwKCksdFI6e30sZVQ6e30sdFBWOnt9LHNFQTpbXX0sbWFuZ2xl
-ZEdsb2JhbE5hbWVzOntJajoiaW50IixDUDoiZG91YmxlIixaWjoibnVtIixxVToiU3RyaW5nIixhMjoi
-Ym9vbCIsYzg6Ik51bGwiLHpNOiJMaXN0In0sbWFuZ2xlZE5hbWVzOnt9LGdldFR5cGVGcm9tTmFtZTpn
-ZXRHbG9iYWxGcm9tTmFtZSxtZXRhZGF0YTpbXSx0eXBlczpbIn4oKSIsImM4KEFqKikiLCJjOCgpIiwi
-YzgoY3YqKSIsIkAoQCkiLCJxVShxVSkiLCJ+KEFqKikiLCJhMihxVSkiLCJ+KH4oKSkiLCJhMihjdixx
-VSxxVSxKUSkiLCJjOChAKSIsIn4oTWg/LE1oPykiLCJAKCkiLCJ+KHFVLEApIiwifihuNixxVSxJaiki
-LCJ+KHFVLHFVKSIsImEyKGtGKSIsImM4KEAsQCkiLCJ+KHh1PHFVPikiLCJjOChlYSopIiwiYjg8Yzg+
-KihBaiopIiwifihxVSxJaikiLCJ+KHFVLHFVPykiLCJuNihALEApIiwifihJaixAKSIsImEyKHVIKSIs
-In4oTWhbR3o/XSkiLCJ+KGVhKSIsImM4KE1oLEd6KSIsInZzPEA+KEApIiwifih1SCx1SD8pIiwifihA
-LEApIiwiQChxVSkiLCJhMih4dTxxVT4pIiwiQChALHFVKSIsInI3KEApIiwiTWg/KEApIiwiRTQoQCki
-LCJMTCooQCkiLCJaMDxxVSosTWgqPiooTEwqKSIsIn4oR0QsQCkiLCJaMDxxVSxxVT4oWjA8cVUscVU+
-LHFVKSIsImM4KFowPHFVKixNaCo+KikiLCJ+KEApIiwicVUqKEFqKikiLCJ+KHFVW0BdKSIsIlR6PEA+
-KEApIiwiYzgoZXcqKSIsInFVKihxVSopIiwicVUqKFowPEAsQD4qKSIsImEyKihINyopIiwicVUocVU/
-KSIsIklqKElqLElqKSIsImM4KH4oKSkiLCJNaD8oTWg/KSIsImM4KEAsR3opIl0saW50ZXJjZXB0b3Jz
-QnlUYWc6bnVsbCxsZWFmVGFnczpudWxsLGFycmF5UnRpOnR5cGVvZiBTeW1ib2w9PSJmdW5jdGlvbiIm
-JnR5cGVvZiBTeW1ib2woKT09InN5bWJvbCI/U3ltYm9sKCIkdGkiKToiJHRpIn0KSC54Yih2LnR5cGVV
-bml2ZXJzZSxKU09OLnBhcnNlKCd7ImlDIjoiTUYiLCJrZCI6Ik1GIiwiYzUiOiJNRiIsInJ4IjoiZWEi
-LCJlNSI6ImVhIiwiWTAiOiJoaSIsInRwIjoiaGkiLCJHOCI6ImV3IiwiTXIiOiJxRSIsImVMIjoicUUi
-LCJJMCI6InVIIiwiaHMiOiJ1SCIsIlhnIjoiUUYiLCJuciI6IkFqIiwieTQiOiJ3NiIsImFQIjoiQ20i
-LCJ4YyI6Im54Iiwia0oiOiJueCIsInpVIjoiRGciLCJkZiI6IkVUIiwieUUiOnsiYTIiOltdfSwid2Ui
-OnsiYzgiOltdfSwiTUYiOnsidm0iOltdfSwiamQiOnsiek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpb
-IjEiXX0sIlBvIjp7ImpkIjpbIjEiXSwiek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIm0x
-Ijp7IkFuIjpbIjEiXX0sInFJIjp7IkNQIjpbXSwiWloiOltdfSwiYlUiOnsiQ1AiOltdLCJJaiI6W10s
-IlpaIjpbXX0sImtEIjp7IkNQIjpbXSwiWloiOltdfSwiRHIiOnsicVUiOltdLCJ2WCI6W119LCJiUSI6
-eyJjWCI6WyIxIl19LCJCUiI6eyJjWCI6WyIyIl19LCJFNyI6eyJBbiI6WyIyIl19LCJaeSI6eyJCUiI6
-WyIxIiwiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIm9sIjp7Ilp5IjpbIjEiLCIyIl0sIkJSIjpb
-IjEiLCIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdLCJjWC5FIjoiMiJ9LCJVcSI6eyJsRCI6WyIyIl0s
-InpNIjpbIjIiXSwiQlIiOlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl19LCJqViI6eyJVcSI6
-WyIxIiwiMiJdLCJsRCI6WyIyIl0sInpNIjpbIjIiXSwiQlIiOlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJj
-WCI6WyIyIl0sImxELkUiOiIyIiwiY1guRSI6IjIifSwibiI6eyJYUyI6W119LCJyMyI6eyJYUyI6W119
-LCJxaiI6eyJsRCI6WyJJaiJdLCJSZSI6WyJJaiJdLCJ6TSI6WyJJaiJdLCJiUSI6WyJJaiJdLCJjWCI6
-WyJJaiJdLCJsRC5FIjoiSWoiLCJSZS5FIjoiSWoifSwiR00iOnsiWFMiOltdfSwiYUwiOnsiYlEiOlsi
-MSJdLCJjWCI6WyIxIl19LCJuSCI6eyJhTCI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdLCJhTC5F
-IjoiMSIsImNYLkUiOiIxIn0sImE3Ijp7IkFuIjpbIjEiXX0sImkxIjp7ImNYIjpbIjIiXSwiY1guRSI6
-IjIifSwieHkiOnsiaTEiOlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0s
-Ik1IIjp7IkFuIjpbIjIiXX0sImxKIjp7ImFMIjpbIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImFM
-LkUiOiIyIiwiY1guRSI6IjIifSwiVTUiOnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJTTyI6eyJBbiI6
-WyIxIl19LCJBTSI6eyJjWCI6WyIxIl0sImNYLkUiOiIxIn0sImQ1Ijp7IkFNIjpbIjEiXSwiYlEiOlsi
-MSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIlUxIjp7IkFuIjpbIjEiXX0sIk1CIjp7ImJRIjpbIjEi
-XSwiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJGdSI6eyJBbiI6WyIxIl19LCJ1NiI6eyJjWCI6WyIxIl0s
-ImNYLkUiOiIxIn0sIkpCIjp7IkFuIjpbIjEiXX0sIncyIjp7ImxEIjpbIjEiXSwiUmUiOlsiMSJdLCJ6
-TSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwid3YiOnsiR0QiOltdfSwiUEQiOnsiR2oiOlsi
-MSIsIjIiXSwiUlUiOlsiMSIsIjIiXSwiUG4iOlsiMSIsIjIiXSwiS1AiOlsiMSIsIjIiXSwiWjAiOlsi
-MSIsIjIiXX0sIldVIjp7IlowIjpbIjEiLCIyIl19LCJMUCI6eyJXVSI6WyIxIiwiMiJdLCJaMCI6WyIx
-IiwiMiJdfSwiWFIiOnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJMSSI6eyJ2USI6W119LCJXMCI6eyJY
-UyI6W119LCJheiI6eyJYUyI6W119LCJ2ViI6eyJYUyI6W119LCJ0ZSI6eyJSeiI6W119LCJYTyI6eyJH
-eiI6W119LCJUcCI6eyJFSCI6W119LCJsYyI6eyJFSCI6W119LCJ6eCI6eyJFSCI6W119LCJyVCI6eyJF
-SCI6W119LCJFcSI6eyJYUyI6W119LCJrWSI6eyJYUyI6W119LCJONSI6eyJZayI6WyIxIiwiMiJdLCJG
-byI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdLCJZay5LIjoiMSIsIllrLlYiOiIyIn0sImk1Ijp7ImJR
-IjpbIjEiXSwiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJONiI6eyJBbiI6WyIxIl19LCJWUiI6eyJ3TCI6
-W10sInZYIjpbXX0sIkVLIjp7ImliIjpbXSwiT2QiOltdfSwiS1ciOnsiY1giOlsiaWIiXSwiY1guRSI6
-ImliIn0sIlBiIjp7IkFuIjpbImliIl19LCJ0USI6eyJPZCI6W119LCJ1biI6eyJjWCI6WyJPZCJdLCJj
-WC5FIjoiT2QifSwiU2QiOnsiQW4iOlsiT2QiXX0sIkVUIjp7IkFTIjpbXX0sIkxaIjp7IlhqIjpbIjEi
-XSwiRVQiOltdLCJBUyI6W119LCJEZyI6eyJsRCI6WyJDUCJdLCJYaiI6WyJDUCJdLCJ6TSI6WyJDUCJd
-LCJFVCI6W10sImJRIjpbIkNQIl0sIkFTIjpbXSwiY1giOlsiQ1AiXSwiU1UiOlsiQ1AiXSwibEQuRSI6
-IkNQIn0sIlBnIjp7ImxEIjpbIklqIl0sIlhqIjpbIklqIl0sInpNIjpbIklqIl0sIkVUIjpbXSwiYlEi
-OlsiSWoiXSwiQVMiOltdLCJjWCI6WyJJaiJdLCJTVSI6WyJJaiJdfSwieGoiOnsibEQiOlsiSWoiXSwi
-WGoiOlsiSWoiXSwiek0iOlsiSWoiXSwiRVQiOltdLCJiUSI6WyJJaiJdLCJBUyI6W10sImNYIjpbIklq
-Il0sIlNVIjpbIklqIl0sImxELkUiOiJJaiJ9LCJkRSI6eyJsRCI6WyJJaiJdLCJYaiI6WyJJaiJdLCJ6
-TSI6WyJJaiJdLCJFVCI6W10sImJRIjpbIklqIl0sIkFTIjpbXSwiY1giOlsiSWoiXSwiU1UiOlsiSWoi
-XSwibEQuRSI6IklqIn0sIlpBIjp7ImxEIjpbIklqIl0sIlhqIjpbIklqIl0sInpNIjpbIklqIl0sIkVU
-IjpbXSwiYlEiOlsiSWoiXSwiQVMiOltdLCJjWCI6WyJJaiJdLCJTVSI6WyJJaiJdLCJsRC5FIjoiSWoi
-fSwiZFQiOnsibEQiOlsiSWoiXSwiWGoiOlsiSWoiXSwiek0iOlsiSWoiXSwiRVQiOltdLCJiUSI6WyJJ
-aiJdLCJBUyI6W10sImNYIjpbIklqIl0sIlNVIjpbIklqIl0sImxELkUiOiJJaiJ9LCJQcSI6eyJsRCI6
-WyJJaiJdLCJYaiI6WyJJaiJdLCJ6TSI6WyJJaiJdLCJFVCI6W10sImJRIjpbIklqIl0sIkFTIjpbXSwi
-Y1giOlsiSWoiXSwiU1UiOlsiSWoiXSwibEQuRSI6IklqIn0sImVFIjp7ImxEIjpbIklqIl0sIlhqIjpb
-IklqIl0sInpNIjpbIklqIl0sIkVUIjpbXSwiYlEiOlsiSWoiXSwiQVMiOltdLCJjWCI6WyJJaiJdLCJT
-VSI6WyJJaiJdLCJsRC5FIjoiSWoifSwiVjYiOnsibEQiOlsiSWoiXSwibjYiOltdLCJYaiI6WyJJaiJd
-LCJ6TSI6WyJJaiJdLCJFVCI6W10sImJRIjpbIklqIl0sIkFTIjpbXSwiY1giOlsiSWoiXSwiU1UiOlsi
-SWoiXSwibEQuRSI6IklqIn0sImtTIjp7IlhTIjpbXX0sImlNIjp7IlhTIjpbXX0sInZzIjp7ImI4Ijpb
-IjEiXX0sIkdWIjp7IkFuIjpbIjEiXX0sInE0Ijp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiQ3ciOnsi
-WFMiOltdfSwiWmYiOnsiUGYiOlsiMSJdfSwibTAiOnsiUW0iOltdfSwiSmkiOnsibTAiOltdLCJRbSI6
-W119LCJiNiI6eyJsZiI6WyIxIl0sInh1IjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImxmLkUi
-OiIxIn0sImxtIjp7IkFuIjpbIjEiXX0sIm1XIjp7ImNYIjpbIjEiXX0sInV5Ijp7ImxEIjpbIjEiXSwi
-ek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sImlsIjp7IllrIjpbIjEiLCIyIl0sIlowIjpb
-IjEiLCIyIl19LCJZayI6eyJaMCI6WyIxIiwiMiJdfSwiUG4iOnsiWjAiOlsiMSIsIjIiXX0sIkdqIjp7
-IlJVIjpbIjEiLCIyIl0sIlBuIjpbIjEiLCIyIl0sIktQIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19
-LCJWaiI6eyJsZiI6WyIxIl0sInh1IjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJYdiI6eyJs
-ZiI6WyIxIl0sInh1IjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJ1dyI6eyJZayI6WyJxVSIs
-IkAiXSwiWjAiOlsicVUiLCJAIl0sIllrLksiOiJxVSIsIllrLlYiOiJAIn0sImk4Ijp7ImFMIjpbInFV
-Il0sImJRIjpbInFVIl0sImNYIjpbInFVIl0sImFMLkUiOiJxVSIsImNYLkUiOiJxVSJ9LCJDViI6eyJV
-ayI6WyJ6TTxJaj4iLCJxVSJdLCJVay5TIjoiek08SWo+In0sIlU4Ijp7IndJIjpbInpNPElqPiIsInFV
-Il19LCJaaSI6eyJVayI6WyJxVSIsInpNPElqPiJdfSwiVWQiOnsiWFMiOltdfSwiSzgiOnsiWFMiOltd
-fSwiYnkiOnsiVWsiOlsiTWg/IiwicVUiXSwiVWsuUyI6Ik1oPyJ9LCJvaiI6eyJ3SSI6WyJNaD8iLCJx
-VSJdfSwiTXgiOnsid0kiOlsicVUiLCJNaD8iXX0sInU1Ijp7IlVrIjpbInFVIiwiek08SWo+Il0sIlVr
-LlMiOiJxVSJ9LCJFMyI6eyJ3SSI6WyJxVSIsInpNPElqPiJdfSwiR1kiOnsid0kiOlsiek08SWo+Iiwi
-cVUiXX0sIkNQIjp7IlpaIjpbXX0sIklqIjp7IlpaIjpbXX0sInpNIjp7ImJRIjpbIjEiXSwiY1giOlsi
-MSJdfSwiaWIiOnsiT2QiOltdfSwieHUiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJxVSI6eyJ2WCI6
-W119LCJDNiI6eyJYUyI6W119LCJFeiI6eyJYUyI6W119LCJGIjp7IlhTIjpbXX0sInUiOnsiWFMiOltd
-fSwiYkoiOnsiWFMiOltdfSwiZVkiOnsiWFMiOltdfSwibXAiOnsiWFMiOltdfSwidWIiOnsiWFMiOltd
-fSwiZHMiOnsiWFMiOltdfSwibGoiOnsiWFMiOltdfSwiVVYiOnsiWFMiOltdfSwiazUiOnsiWFMiOltd
-fSwiS1kiOnsiWFMiOltdfSwiYyI6eyJYUyI6W119LCJDRCI6eyJSeiI6W119LCJhRSI6eyJSeiI6W119
-LCJaZCI6eyJHeiI6W119LCJSbiI6eyJCTCI6W119LCJEbiI6eyJpRCI6W119LCJVZiI6eyJpRCI6W119
-LCJxZSI6eyJpRCI6W119LCJjdiI6eyJ1SCI6W10sIkQwIjpbXX0sImZKIjp7IkQwIjpbXX0sIndhIjp7
-IkQwIjpbXX0sIkFqIjp7ImVhIjpbXX0sInVIIjp7IkQwIjpbXX0sImV3Ijp7ImVhIjpbXX0sInc2Ijp7
-ImVhIjpbXX0sIkpRIjp7ImtGIjpbXX0sInFFIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJHaCI6
-eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiZlkiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIm5C
-Ijp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJRUCI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwi
-bngiOnsidUgiOltdLCJEMCI6W119LCJRRiI6eyJ1SCI6W10sIkQwIjpbXX0sIklCIjp7InRuIjpbIlpa
-Il19LCJ3eiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImxELkUi
-OiIxIn0sImhIIjp7IkF6IjpbXX0sImg0Ijp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJWYiI6eyJ1
-SCI6W10sIkQwIjpbXX0sImU3Ijp7ImxEIjpbInVIIl0sInpNIjpbInVIIl0sImJRIjpbInVIIl0sImNY
-IjpbInVIIl0sImxELkUiOiJ1SCJ9LCJCSCI6eyJsRCI6WyJ1SCJdLCJHbSI6WyJ1SCJdLCJ6TSI6WyJ1
-SCJdLCJYaiI6WyJ1SCJdLCJiUSI6WyJ1SCJdLCJjWCI6WyJ1SCJdLCJsRC5FIjoidUgiLCJHbS5FIjoi
-dUgifSwiU04iOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sImxwIjp7ImN2IjpbXSwidUgiOltdLCJE
-MCI6W119LCJUYiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiSXYiOnsiY3YiOltdLCJ1SCI6W10s
-IkQwIjpbXX0sIldQIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJ5WSI6eyJjdiI6W10sInVIIjpb
-XSwiRDAiOltdfSwiSzUiOnsidjYiOltdLCJEMCI6W119LCJDbSI6eyJEMCI6W119LCJDUSI6eyJ1SCI6
-W10sIkQwIjpbXX0sInc0Ijp7InRuIjpbIlpaIl19LCJyaCI6eyJsRCI6WyJ1SCJdLCJHbSI6WyJ1SCJd
-LCJ6TSI6WyJ1SCJdLCJYaiI6WyJ1SCJdLCJiUSI6WyJ1SCJdLCJjWCI6WyJ1SCJdLCJsRC5FIjoidUgi
-LCJHbS5FIjoidUgifSwiY2YiOnsiWWsiOlsicVUiLCJxVSJdLCJaMCI6WyJxVSIsInFVIl19LCJpNyI6
-eyJZayI6WyJxVSIsInFVIl0sIlowIjpbInFVIiwicVUiXSwiWWsuSyI6InFVIiwiWWsuViI6InFVIn0s
-IlN5Ijp7IllrIjpbInFVIiwicVUiXSwiWjAiOlsicVUiLCJxVSJdLCJZay5LIjoicVUiLCJZay5WIjoi
-cVUifSwiSTQiOnsibGYiOlsicVUiXSwieHUiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwi
-bGYuRSI6InFVIn0sIlJPIjp7InFoIjpbIjEiXX0sImV1Ijp7IlJPIjpbIjEiXSwicWgiOlsiMSJdfSwi
-eEMiOnsiTU8iOlsiMSJdfSwidkQiOnsia0YiOltdfSwibTYiOnsia0YiOltdfSwiY3QiOnsia0YiOltd
-fSwiT3ciOnsia0YiOltdfSwiVzkiOnsiQW4iOlsiMSJdfSwiZFciOnsidjYiOltdLCJEMCI6W119LCJt
-ayI6eyJ5MCI6W119LCJLbyI6eyJvbiI6W119LCJBcyI6eyJsZiI6WyJxVSJdLCJ4dSI6WyJxVSJdLCJi
-USI6WyJxVSJdLCJjWCI6WyJxVSJdfSwicjciOnsiRTQiOltdfSwiVHoiOnsibEQiOlsiMSJdLCJ6TSI6
-WyIxIl0sImJRIjpbIjEiXSwiRTQiOltdLCJjWCI6WyIxIl0sImxELkUiOiIxIn0sIm5kIjp7ImhpIjpb
-XSwiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIktlIjp7ImxmIjpbInFVIl0sInh1IjpbInFVIl0sImJR
-IjpbInFVIl0sImNYIjpbInFVIl0sImxmLkUiOiJxVSJ9LCJoaSI6eyJjdiI6W10sInVIIjpbXSwiRDAi
-OltdfSwiUVciOnsiWFMiOltdLCJSeiI6W119LCJYQSI6eyJrRiI6W119LCJ2dCI6eyJEOCI6W119LCJj
-RCI6eyJEOCI6W119LCJkdiI6eyJSeiI6W119LCJPRiI6eyJmdiI6W119LCJydSI6eyJmdiI6W119LCJJ
-ViI6eyJmdiI6W119LCJuNiI6eyJ6TSI6WyJJaiJdLCJiUSI6WyJJaiJdLCJjWCI6WyJJaiJdLCJBUyI6
-W119fScpKQpILkZGKHYudHlwZVVuaXZlcnNlLEpTT04ucGFyc2UoJ3sidzIiOjEsIlFDIjoyLCJMWiI6
-MSwia1QiOjIsIm1XIjoxLCJ1eSI6MSwiaWwiOjIsIlZqIjoxLCJYdiI6MSwiblkiOjEsIldZIjoxLCJw
-UiI6MSwiY28iOjF9JykpCnZhciB1PXtsOiJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEg
-VVJJIHdpdGggYSBmcmFnbWVudCBjb21wb25lbnQiLGk6IkNhbm5vdCBleHRyYWN0IGEgZmlsZSBwYXRo
-IGZyb20gYSBVUkkgd2l0aCBhIHF1ZXJ5IGNvbXBvbmVudCIsajoiQ2Fubm90IGV4dHJhY3QgYSBub24t
-V2luZG93cyBmaWxlIHBhdGggZnJvbSBhIGZpbGUgVVJJIHdpdGggYW4gYXV0aG9yaXR5IixnOiJgbnVs
-bGAgZW5jb3VudGVyZWQgYXMgdGhlIHJlc3VsdCBmcm9tIGV4cHJlc3Npb24gd2l0aCB0eXBlIGBOZXZl
-cmAuIixkOiJhcmVhLWFuYWx5emVyLGFuYWx5emVyLW5uYmQtbWlncmF0aW9uLHR5cGUtYnVnIn0KdmFy
-IHQ9KGZ1bmN0aW9uIHJ0aWkoKXt2YXIgcz1ILk4wCnJldHVybntuOnMoIkN3IiksY1I6cygibkIiKSx3
-OnMoIkF6IikscDpzKCJRUCIpLGdGOnMoIlBEPEdELEA+IiksZDpzKCJiUTxAPiIpLGg6cygiY3YiKSxy
-OnMoIlhTIiksQjpzKCJlYSIpLGFTOnMoIkQwIiksZzg6cygiUnoiKSxjODpzKCJoSCIpLFk6cygiRUgi
-KSxlOnMoImI4PEA+IiksSTpzKCJTZyIpLG86cygidlEiKSxlaDpzKCJjWDx1SD4iKSxROnMoImNYPHFV
-PiIpLHU6cygiY1g8QD4iKSx2OnMoImpkPGtGPiIpLHM6cygiamQ8cVU+IiksZ046cygiamQ8bjY+Iiks
-YjpzKCJqZDxAPiIpLGE6cygiamQ8SWo+IiksZDc6cygiamQ8U2UqPiIpLGg0OnMoImpkPGo4Kj4iKSxH
-OnMoImpkPFowPHFVKixNaCo+Kj4iKSxjUTpzKCJqZDxEOCo+IiksaTpzKCJqZDxxVSo+IiksYUE6cygi
-amQ8eUQqPiIpLGFKOnMoImpkPHdiKj4iKSxWOnMoImpkPElqKj4iKSxkNDpzKCJqZDxxVT8+IiksVDpz
-KCJ3ZSIpLGVIOnMoInZtIikseDpzKCJjNSIpLGFVOnMoIlhqPEA+IiksYW06cygiVHo8QD4iKSxlbzpz
-KCJONTxHRCxAPiIpLGR6OnMoImhGIiksRDpzKCJ6TTxxVT4iKSxqOnMoInpNPEA+IiksTDpzKCJ6TTxJ
-aj4iKSxKOnMoIlowPHFVLHFVPiIpLGY6cygiWjA8QCxAPiIpLGRvOnMoImxKPHFVLEA+IiksZmo6cygi
-bEo8cVUqLHFVPiIpLGZQOnMoImxKPHFVKixxVSo+IiksZEU6cygiRVQiKSxibTpzKCJWNiIpLEE6cygi
-dUgiKSxFOnMoImtGIiksUDpzKCJjOCIpLEs6cygiTWgiKSxxOnMoInRuPFpaPiIpLGZ2OnMoIndMIiks
-ZXc6cygibmQiKSxDOnMoInh1PHFVPiIpLGw6cygiR3oiKSxOOnMoInFVIiksZDA6cygicVUocVUqKSIp
-LGc3OnMoImhpIiksZm86cygiR0QiKSxhVzpzKCJ5WSIpLGFrOnMoIkFTIiksZ2M6cygibjYiKSxiSjpz
-KCJrZCIpLGR3OnMoIkdqPHFVLHFVPiIpLGREOnMoImlEIiksZUo6cygidTY8cVU+IiksZzQ6cygiSzUi
-KSxjaTpzKCJ2NiIpLGcyOnMoIkNtIiksYkM6cygiWmY8ZkoqPiIpLGg5OnMoIkNRIiksYWM6cygiZTci
-KSxrOnMoImV1PEFqKj4iKSxSOnMoInd6PGN2Kj4iKSxjOnMoInZzPEA+IiksZko6cygidnM8SWo+Iiks
-Z1Y6cygidnM8ZkoqPiIpLGNyOnMoIkpRIikseTpzKCJhMiIpLGFsOnMoImEyKE1oKSIpLGdSOnMoIkNQ
-IiksejpzKCJAIiksZk86cygiQCgpIiksYkk6cygiQChNaCkiKSxhZzpzKCJAKE1oLEd6KSIpLGJVOnMo
-IkAoeHU8cVU+KSIpLGRPOnMoIkAocVUpIiksYjg6cygiQChALEApIiksUzpzKCJJaiIpLGRkOnMoIkdo
-KiIpLGc6cygiY3YqIiksYUw6cygiZWEqIiksYVg6cygiTEwqIiksZkU6cygiSDcqIiksVTpzKCJjWDxA
-PioiKSxkSDpzKCJFNCoiKSxmSzpzKCJ6TTxAPioiKSxkXzpzKCJ6TTxqOCo+KiIpLGRwOnMoInpNPFow
-PHFVKixNaCo+Kj4qIiksZUU6cygiek08TWgqPioiKSxhdzpzKCJaMDxALEA+KiIpLHQ6cygiWjA8cVUq
-LE1oKj4qIiksTzpzKCJBaioiKSxjRjpzKCIwJioiKSxfOnMoIk1oKiIpLGVROnMoImV3KiIpLFg6cygi
-cVUqIiksZXE6cygicVUqKHFVKikiKSxjaDpzKCJEMD8iKSxiRzpzKCJiODxjOD4/IiksYms6cygiek08
-cVU+PyIpLGJNOnMoInpNPEA+PyIpLGNaOnMoIlowPHFVLHFVPj8iKSxjOTpzKCJaMDxxVSxAPj8iKSxX
-OnMoIk1oPyIpLEY6cygiRmU8QCxAPj8iKSxtOnMoImJuPyIpLGI3OnMoImEyKE1oKT8iKSxidzpzKCJA
-KGVhKT8iKSxmVjpzKCJNaD8oTWg/LE1oPyk/IiksZEE6cygiTWg/KEApPyIpLFo6cygifigpPyIpLGVi
-OnMoIn4oZXcqKT8iKSxkaTpzKCJaWiIpLEg6cygifiIpLE06cygifigpIiksZUE6cygifihxVSxxVSki
-KSxjQTpzKCJ+KHFVLEApIil9fSkoKTsoZnVuY3Rpb24gY29uc3RhbnRzKCl7dmFyIHM9aHVua0hlbHBl
-cnMubWFrZUNvbnN0TGlzdApDLnhuPVcuR2gucHJvdG90eXBlCkMuUlk9Vy5RUC5wcm90b3R5cGUKQy5t
-SD1XLmFlLnByb3RvdHlwZQpDLkJaPVcuVmIucHJvdG90eXBlCkMuRHQ9Vy5mSi5wcm90b3R5cGUKQy5P
-az1KLkd2LnByb3RvdHlwZQpDLk5tPUouamQucHJvdG90eXBlCkMuam49Si5iVS5wcm90b3R5cGUKQy5D
-RD1KLnFJLnByb3RvdHlwZQpDLnhCPUouRHIucHJvdG90eXBlCkMuREc9Si5jNS5wcm90b3R5cGUKQy5F
-eD1XLnc3LnByb3RvdHlwZQpDLk5BPUguVjYucHJvdG90eXBlCkMudDU9Vy5CSC5wcm90b3R5cGUKQy5M
-dD1XLlNOLnByb3RvdHlwZQpDLlpRPUouaUMucHJvdG90eXBlCkMuSWU9Vy5UYi5wcm90b3R5cGUKQy52
-Qj1KLmtkLnByb3RvdHlwZQpDLm9sPVcuSzUucHJvdG90eXBlCkMueTg9bmV3IFAuVTgoKQpDLmg5PW5l
-dyBQLkNWKCkKQy5Hdz1uZXcgSC5GdShILk4wKCJGdTwwJio+IikpCkMuTzQ9ZnVuY3Rpb24gZ2V0VGFn
-RmFsbGJhY2sobykgewogIHZhciBzID0gT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKG8pOwog
-IHJldHVybiBzLnN1YnN0cmluZyg4LCBzLmxlbmd0aCAtIDEpOwp9CkMuWXE9ZnVuY3Rpb24oKSB7CiAg
-dmFyIHRvU3RyaW5nRnVuY3Rpb24gPSBPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nOwogIGZ1bmN0aW9u
-IGdldFRhZyhvKSB7CiAgICB2YXIgcyA9IHRvU3RyaW5nRnVuY3Rpb24uY2FsbChvKTsKICAgIHJldHVy
-biBzLnN1YnN0cmluZyg4LCBzLmxlbmd0aCAtIDEpOwogIH0KICBmdW5jdGlvbiBnZXRVbmtub3duVGFn
-KG9iamVjdCwgdGFnKSB7CiAgICBpZiAoL15IVE1MW0EtWl0uKkVsZW1lbnQkLy50ZXN0KHRhZykpIHsK
-ICAgICAgdmFyIG5hbWUgPSB0b1N0cmluZ0Z1bmN0aW9uLmNhbGwob2JqZWN0KTsKICAgICAgaWYgKG5h
-bWUgPT0gIltvYmplY3QgT2JqZWN0XSIpIHJldHVybiBudWxsOwogICAgICByZXR1cm4gIkhUTUxFbGVt
-ZW50IjsKICAgIH0KICB9CiAgZnVuY3Rpb24gZ2V0VW5rbm93blRhZ0dlbmVyaWNCcm93c2VyKG9iamVj
-dCwgdGFnKSB7CiAgICBpZiAoc2VsZi5IVE1MRWxlbWVudCAmJiBvYmplY3QgaW5zdGFuY2VvZiBIVE1M
-RWxlbWVudCkgcmV0dXJuICJIVE1MRWxlbWVudCI7CiAgICByZXR1cm4gZ2V0VW5rbm93blRhZyhvYmpl
-Y3QsIHRhZyk7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZyh0YWcpIHsKICAgIGlmICh0eXBl
-b2Ygd2luZG93ID09ICJ1bmRlZmluZWQiKSByZXR1cm4gbnVsbDsKICAgIGlmICh0eXBlb2Ygd2luZG93
-W3RhZ10gPT0gInVuZGVmaW5lZCIpIHJldHVybiBudWxsOwogICAgdmFyIGNvbnN0cnVjdG9yID0gd2lu
-ZG93W3RhZ107CiAgICBpZiAodHlwZW9mIGNvbnN0cnVjdG9yICE9ICJmdW5jdGlvbiIpIHJldHVybiBu
-dWxsOwogICAgcmV0dXJuIGNvbnN0cnVjdG9yLnByb3RvdHlwZTsKICB9CiAgZnVuY3Rpb24gZGlzY3Jp
-bWluYXRvcih0YWcpIHsgcmV0dXJuIG51bGw7IH0KICB2YXIgaXNCcm93c2VyID0gdHlwZW9mIG5hdmln
-YXRvciA9PSAib2JqZWN0IjsKICByZXR1cm4gewogICAgZ2V0VGFnOiBnZXRUYWcsCiAgICBnZXRVbmtu
-b3duVGFnOiBpc0Jyb3dzZXIgPyBnZXRVbmtub3duVGFnR2VuZXJpY0Jyb3dzZXIgOiBnZXRVbmtub3du
-VGFnLAogICAgcHJvdG90eXBlRm9yVGFnOiBwcm90b3R5cGVGb3JUYWcsCiAgICBkaXNjcmltaW5hdG9y
-OiBkaXNjcmltaW5hdG9yIH07Cn0KQy53Yj1mdW5jdGlvbihnZXRUYWdGYWxsYmFjaykgewogIHJldHVy
-biBmdW5jdGlvbihob29rcykgewogICAgaWYgKHR5cGVvZiBuYXZpZ2F0b3IgIT0gIm9iamVjdCIpIHJl
-dHVybiBob29rczsKICAgIHZhciB1YSA9IG5hdmlnYXRvci51c2VyQWdlbnQ7CiAgICBpZiAodWEuaW5k
-ZXhPZigiRHVtcFJlbmRlclRyZWUiKSA+PSAwKSByZXR1cm4gaG9va3M7CiAgICBpZiAodWEuaW5kZXhP
-ZigiQ2hyb21lIikgPj0gMCkgewogICAgICBmdW5jdGlvbiBjb25maXJtKHApIHsKICAgICAgICByZXR1
-cm4gdHlwZW9mIHdpbmRvdyA9PSAib2JqZWN0IiAmJiB3aW5kb3dbcF0gJiYgd2luZG93W3BdLm5hbWUg
-PT0gcDsKICAgICAgfQogICAgICBpZiAoY29uZmlybSgiV2luZG93IikgJiYgY29uZmlybSgiSFRNTEVs
-ZW1lbnQiKSkgcmV0dXJuIGhvb2tzOwogICAgfQogICAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRmFsbGJh
-Y2s7CiAgfTsKfQpDLktVPWZ1bmN0aW9uKGhvb2tzKSB7CiAgaWYgKHR5cGVvZiBkYXJ0RXhwZXJpbWVu
-dGFsRml4dXBHZXRUYWcgIT0gImZ1bmN0aW9uIikgcmV0dXJuIGhvb2tzOwogIGhvb2tzLmdldFRhZyA9
-IGRhcnRFeHBlcmltZW50YWxGaXh1cEdldFRhZyhob29rcy5nZXRUYWcpOwp9CkMuZlE9ZnVuY3Rpb24o
-aG9va3MpIHsKICB2YXIgZ2V0VGFnID0gaG9va3MuZ2V0VGFnOwogIHZhciBwcm90b3R5cGVGb3JUYWcg
-PSBob29rcy5wcm90b3R5cGVGb3JUYWc7CiAgZnVuY3Rpb24gZ2V0VGFnRml4ZWQobykgewogICAgdmFy
-IHRhZyA9IGdldFRhZyhvKTsKICAgIGlmICh0YWcgPT0gIkRvY3VtZW50IikgewogICAgICBpZiAoISFv
-LnhtbFZlcnNpb24pIHJldHVybiAiIURvY3VtZW50IjsKICAgICAgcmV0dXJuICIhSFRNTERvY3VtZW50
-IjsKICAgIH0KICAgIHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0ZpeGVk
-KHRhZykgewogICAgaWYgKHRhZyA9PSAiRG9jdW1lbnQiKSByZXR1cm4gbnVsbDsKICAgIHJldHVybiBw
-cm90b3R5cGVGb3JUYWcodGFnKTsKICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRml4ZWQ7CiAgaG9v
-a3MucHJvdG90eXBlRm9yVGFnID0gcHJvdG90eXBlRm9yVGFnRml4ZWQ7Cn0KQy5kaz1mdW5jdGlvbiho
-b29rcykgewogIHZhciB1c2VyQWdlbnQgPSB0eXBlb2YgbmF2aWdhdG9yID09ICJvYmplY3QiID8gbmF2
-aWdhdG9yLnVzZXJBZ2VudCA6ICIiOwogIGlmICh1c2VyQWdlbnQuaW5kZXhPZigiRmlyZWZveCIpID09
-IC0xKSByZXR1cm4gaG9va3M7CiAgdmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tN
-YXAgPSB7CiAgICAiQmVmb3JlVW5sb2FkRXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6
-ICJDbGlwYm9hcmQiLAogICAgIkdlb0dlb2xvY2F0aW9uIjogIkdlb2xvY2F0aW9uIiwKICAgICJMb2Nh
-dGlvbiI6ICIhTG9jYXRpb24iLAogICAgIldvcmtlck1lc3NhZ2VFdmVudCI6ICJNZXNzYWdlRXZlbnQi
-LAogICAgIlhNTERvY3VtZW50IjogIiFEb2N1bWVudCJ9OwogIGZ1bmN0aW9uIGdldFRhZ0ZpcmVmb3go
-bykgewogICAgdmFyIHRhZyA9IGdldFRhZyhvKTsKICAgIHJldHVybiBxdWlja01hcFt0YWddIHx8IHRh
-ZzsKICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRmlyZWZveDsKfQpDLnhpPWZ1bmN0aW9uKGhvb2tz
-KSB7CiAgdmFyIHVzZXJBZ2VudCA9IHR5cGVvZiBuYXZpZ2F0b3IgPT0gIm9iamVjdCIgPyBuYXZpZ2F0
-b3IudXNlckFnZW50IDogIiI7CiAgaWYgKHVzZXJBZ2VudC5pbmRleE9mKCJUcmlkZW50LyIpID09IC0x
-KSByZXR1cm4gaG9va3M7CiAgdmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAg
-PSB7CiAgICAiQmVmb3JlVW5sb2FkRXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJD
-bGlwYm9hcmQiLAogICAgIkhUTUxEREVsZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIkhUTUxEVEVs
-ZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIkhUTUxQaHJhc2VFbGVtZW50IjogIkhUTUxFbGVtZW50
-IiwKICAgICJQb3NpdGlvbiI6ICJHZW9wb3NpdGlvbiIKICB9OwogIGZ1bmN0aW9uIGdldFRhZ0lFKG8p
-IHsKICAgIHZhciB0YWcgPSBnZXRUYWcobyk7CiAgICB2YXIgbmV3VGFnID0gcXVpY2tNYXBbdGFnXTsK
-ICAgIGlmIChuZXdUYWcpIHJldHVybiBuZXdUYWc7CiAgICBpZiAodGFnID09ICJPYmplY3QiKSB7CiAg
-ICAgIGlmICh3aW5kb3cuRGF0YVZpZXcgJiYgKG8gaW5zdGFuY2VvZiB3aW5kb3cuRGF0YVZpZXcpKSBy
-ZXR1cm4gIkRhdGFWaWV3IjsKICAgIH0KICAgIHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3Rv
-dHlwZUZvclRhZ0lFKHRhZykgewogICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBp
-ZiAoY29uc3RydWN0b3IgPT0gbnVsbCkgcmV0dXJuIG51bGw7CiAgICByZXR1cm4gY29uc3RydWN0b3Iu
-cHJvdG90eXBlOwogIH0KICBob29rcy5nZXRUYWcgPSBnZXRUYWdJRTsKICBob29rcy5wcm90b3R5cGVG
-b3JUYWcgPSBwcm90b3R5cGVGb3JUYWdJRTsKfQpDLmk3PWZ1bmN0aW9uKGhvb2tzKSB7IHJldHVybiBo
-b29rczsgfQoKQy5DdD1uZXcgUC5ieSgpCkMuRXE9bmV3IFAuazUoKQpDLnhNPW5ldyBQLnU1KCkKQy5R
-az1uZXcgUC5FMygpCkMuTnY9bmV3IEgua3IoKQpDLk5VPW5ldyBQLkppKCkKQy5wZD1uZXcgUC5aZCgp
-CkMuQWQ9bmV3IFIuSDcoMCwiSGludEFjdGlvbktpbmQuYWRkTnVsbGFibGVIaW50IikKQy5uZT1uZXcg
-Ui5INygxLCJIaW50QWN0aW9uS2luZC5hZGROb25OdWxsYWJsZUhpbnQiKQpDLm15PW5ldyBSLkg3KDIs
-IkhpbnRBY3Rpb25LaW5kLmNoYW5nZVRvTnVsbGFibGVIaW50IikKQy5yeD1uZXcgUi5INygzLCJIaW50
-QWN0aW9uS2luZC5jaGFuZ2VUb05vbk51bGxhYmxlSGludCIpCkMud1Y9bmV3IFIuSDcoNCwiSGludEFj
-dGlvbktpbmQucmVtb3ZlTnVsbGFibGVIaW50IikKQy5mUj1uZXcgUi5INyg1LCJIaW50QWN0aW9uS2lu
-ZC5yZW1vdmVOb25OdWxsYWJsZUhpbnQiKQpDLkEzPW5ldyBQLk14KG51bGwpCkMublg9bmV3IFAub2oo
-bnVsbCkKQy5jdz1uZXcgTC5HYigwLCJVbml0TWlncmF0aW9uU3RhdHVzLmFscmVhZHlNaWdyYXRlZCIp
-CkMuZGM9bmV3IEwuR2IoMSwiVW5pdE1pZ3JhdGlvblN0YXR1cy5pbmRldGVybWluYXRlIikKQy5XRD1u
-ZXcgTC5HYigyLCJVbml0TWlncmF0aW9uU3RhdHVzLm1pZ3JhdGluZyIpCkMuWGo9bmV3IEwuR2IoMywi
-VW5pdE1pZ3JhdGlvblN0YXR1cy5vcHRpbmdPdXQiKQpDLmwwPUguVk0ocyhbQy5jdyxDLmRjLEMuV0Qs
-Qy5Yal0pLEguTjAoImpkPEdiKj4iKSkKQy5haz1ILlZNKHMoWzAsMCwzMjc3NiwzMzc5MiwxLDEwMjQw
-LDAsMF0pLHQuVikKQy5jbT1ILlZNKHMoWyIqOjpjbGFzcyIsIio6OmRpciIsIio6OmRyYWdnYWJsZSIs
-Iio6OmhpZGRlbiIsIio6OmlkIiwiKjo6aW5lcnQiLCIqOjppdGVtcHJvcCIsIio6Oml0ZW1yZWYiLCIq
-OjppdGVtc2NvcGUiLCIqOjpsYW5nIiwiKjo6c3BlbGxjaGVjayIsIio6OnRpdGxlIiwiKjo6dHJhbnNs
-YXRlIiwiQTo6YWNjZXNza2V5IiwiQTo6Y29vcmRzIiwiQTo6aHJlZmxhbmciLCJBOjpuYW1lIiwiQTo6
-c2hhcGUiLCJBOjp0YWJpbmRleCIsIkE6OnRhcmdldCIsIkE6OnR5cGUiLCJBUkVBOjphY2Nlc3NrZXki
-LCJBUkVBOjphbHQiLCJBUkVBOjpjb29yZHMiLCJBUkVBOjpub2hyZWYiLCJBUkVBOjpzaGFwZSIsIkFS
-RUE6OnRhYmluZGV4IiwiQVJFQTo6dGFyZ2V0IiwiQVVESU86OmNvbnRyb2xzIiwiQVVESU86Omxvb3Ai
-LCJBVURJTzo6bWVkaWFncm91cCIsIkFVRElPOjptdXRlZCIsIkFVRElPOjpwcmVsb2FkIiwiQkRPOjpk
-aXIiLCJCT0RZOjphbGluayIsIkJPRFk6OmJnY29sb3IiLCJCT0RZOjpsaW5rIiwiQk9EWTo6dGV4dCIs
-IkJPRFk6OnZsaW5rIiwiQlI6OmNsZWFyIiwiQlVUVE9OOjphY2Nlc3NrZXkiLCJCVVRUT046OmRpc2Fi
-bGVkIiwiQlVUVE9OOjpuYW1lIiwiQlVUVE9OOjp0YWJpbmRleCIsIkJVVFRPTjo6dHlwZSIsIkJVVFRP
-Tjo6dmFsdWUiLCJDQU5WQVM6OmhlaWdodCIsIkNBTlZBUzo6d2lkdGgiLCJDQVBUSU9OOjphbGlnbiIs
-IkNPTDo6YWxpZ24iLCJDT0w6OmNoYXIiLCJDT0w6OmNoYXJvZmYiLCJDT0w6OnNwYW4iLCJDT0w6OnZh
-bGlnbiIsIkNPTDo6d2lkdGgiLCJDT0xHUk9VUDo6YWxpZ24iLCJDT0xHUk9VUDo6Y2hhciIsIkNPTEdS
-T1VQOjpjaGFyb2ZmIiwiQ09MR1JPVVA6OnNwYW4iLCJDT0xHUk9VUDo6dmFsaWduIiwiQ09MR1JPVVA6
-OndpZHRoIiwiQ09NTUFORDo6Y2hlY2tlZCIsIkNPTU1BTkQ6OmNvbW1hbmQiLCJDT01NQU5EOjpkaXNh
-YmxlZCIsIkNPTU1BTkQ6OmxhYmVsIiwiQ09NTUFORDo6cmFkaW9ncm91cCIsIkNPTU1BTkQ6OnR5cGUi
-LCJEQVRBOjp2YWx1ZSIsIkRFTDo6ZGF0ZXRpbWUiLCJERVRBSUxTOjpvcGVuIiwiRElSOjpjb21wYWN0
-IiwiRElWOjphbGlnbiIsIkRMOjpjb21wYWN0IiwiRklFTERTRVQ6OmRpc2FibGVkIiwiRk9OVDo6Y29s
-b3IiLCJGT05UOjpmYWNlIiwiRk9OVDo6c2l6ZSIsIkZPUk06OmFjY2VwdCIsIkZPUk06OmF1dG9jb21w
-bGV0ZSIsIkZPUk06OmVuY3R5cGUiLCJGT1JNOjptZXRob2QiLCJGT1JNOjpuYW1lIiwiRk9STTo6bm92
-YWxpZGF0ZSIsIkZPUk06OnRhcmdldCIsIkZSQU1FOjpuYW1lIiwiSDE6OmFsaWduIiwiSDI6OmFsaWdu
-IiwiSDM6OmFsaWduIiwiSDQ6OmFsaWduIiwiSDU6OmFsaWduIiwiSDY6OmFsaWduIiwiSFI6OmFsaWdu
-IiwiSFI6Om5vc2hhZGUiLCJIUjo6c2l6ZSIsIkhSOjp3aWR0aCIsIkhUTUw6OnZlcnNpb24iLCJJRlJB
-TUU6OmFsaWduIiwiSUZSQU1FOjpmcmFtZWJvcmRlciIsIklGUkFNRTo6aGVpZ2h0IiwiSUZSQU1FOjpt
-YXJnaW5oZWlnaHQiLCJJRlJBTUU6Om1hcmdpbndpZHRoIiwiSUZSQU1FOjp3aWR0aCIsIklNRzo6YWxp
-Z24iLCJJTUc6OmFsdCIsIklNRzo6Ym9yZGVyIiwiSU1HOjpoZWlnaHQiLCJJTUc6OmhzcGFjZSIsIklN
-Rzo6aXNtYXAiLCJJTUc6Om5hbWUiLCJJTUc6OnVzZW1hcCIsIklNRzo6dnNwYWNlIiwiSU1HOjp3aWR0
-aCIsIklOUFVUOjphY2NlcHQiLCJJTlBVVDo6YWNjZXNza2V5IiwiSU5QVVQ6OmFsaWduIiwiSU5QVVQ6
-OmFsdCIsIklOUFVUOjphdXRvY29tcGxldGUiLCJJTlBVVDo6YXV0b2ZvY3VzIiwiSU5QVVQ6OmNoZWNr
-ZWQiLCJJTlBVVDo6ZGlzYWJsZWQiLCJJTlBVVDo6aW5wdXRtb2RlIiwiSU5QVVQ6OmlzbWFwIiwiSU5Q
-VVQ6Omxpc3QiLCJJTlBVVDo6bWF4IiwiSU5QVVQ6Om1heGxlbmd0aCIsIklOUFVUOjptaW4iLCJJTlBV
-VDo6bXVsdGlwbGUiLCJJTlBVVDo6bmFtZSIsIklOUFVUOjpwbGFjZWhvbGRlciIsIklOUFVUOjpyZWFk
-b25seSIsIklOUFVUOjpyZXF1aXJlZCIsIklOUFVUOjpzaXplIiwiSU5QVVQ6OnN0ZXAiLCJJTlBVVDo6
-dGFiaW5kZXgiLCJJTlBVVDo6dHlwZSIsIklOUFVUOjp1c2VtYXAiLCJJTlBVVDo6dmFsdWUiLCJJTlM6
-OmRhdGV0aW1lIiwiS0VZR0VOOjpkaXNhYmxlZCIsIktFWUdFTjo6a2V5dHlwZSIsIktFWUdFTjo6bmFt
-ZSIsIkxBQkVMOjphY2Nlc3NrZXkiLCJMQUJFTDo6Zm9yIiwiTEVHRU5EOjphY2Nlc3NrZXkiLCJMRUdF
-TkQ6OmFsaWduIiwiTEk6OnR5cGUiLCJMSTo6dmFsdWUiLCJMSU5LOjpzaXplcyIsIk1BUDo6bmFtZSIs
-Ik1FTlU6OmNvbXBhY3QiLCJNRU5VOjpsYWJlbCIsIk1FTlU6OnR5cGUiLCJNRVRFUjo6aGlnaCIsIk1F
-VEVSOjpsb3ciLCJNRVRFUjo6bWF4IiwiTUVURVI6Om1pbiIsIk1FVEVSOjp2YWx1ZSIsIk9CSkVDVDo6
-dHlwZW11c3RtYXRjaCIsIk9MOjpjb21wYWN0IiwiT0w6OnJldmVyc2VkIiwiT0w6OnN0YXJ0IiwiT0w6
-OnR5cGUiLCJPUFRHUk9VUDo6ZGlzYWJsZWQiLCJPUFRHUk9VUDo6bGFiZWwiLCJPUFRJT046OmRpc2Fi
-bGVkIiwiT1BUSU9OOjpsYWJlbCIsIk9QVElPTjo6c2VsZWN0ZWQiLCJPUFRJT046OnZhbHVlIiwiT1VU
-UFVUOjpmb3IiLCJPVVRQVVQ6Om5hbWUiLCJQOjphbGlnbiIsIlBSRTo6d2lkdGgiLCJQUk9HUkVTUzo6
-bWF4IiwiUFJPR1JFU1M6Om1pbiIsIlBST0dSRVNTOjp2YWx1ZSIsIlNFTEVDVDo6YXV0b2NvbXBsZXRl
-IiwiU0VMRUNUOjpkaXNhYmxlZCIsIlNFTEVDVDo6bXVsdGlwbGUiLCJTRUxFQ1Q6Om5hbWUiLCJTRUxF
-Q1Q6OnJlcXVpcmVkIiwiU0VMRUNUOjpzaXplIiwiU0VMRUNUOjp0YWJpbmRleCIsIlNPVVJDRTo6dHlw
-ZSIsIlRBQkxFOjphbGlnbiIsIlRBQkxFOjpiZ2NvbG9yIiwiVEFCTEU6OmJvcmRlciIsIlRBQkxFOjpj
-ZWxscGFkZGluZyIsIlRBQkxFOjpjZWxsc3BhY2luZyIsIlRBQkxFOjpmcmFtZSIsIlRBQkxFOjpydWxl
-cyIsIlRBQkxFOjpzdW1tYXJ5IiwiVEFCTEU6OndpZHRoIiwiVEJPRFk6OmFsaWduIiwiVEJPRFk6OmNo
-YXIiLCJUQk9EWTo6Y2hhcm9mZiIsIlRCT0RZOjp2YWxpZ24iLCJURDo6YWJiciIsIlREOjphbGlnbiIs
-IlREOjpheGlzIiwiVEQ6OmJnY29sb3IiLCJURDo6Y2hhciIsIlREOjpjaGFyb2ZmIiwiVEQ6OmNvbHNw
-YW4iLCJURDo6aGVhZGVycyIsIlREOjpoZWlnaHQiLCJURDo6bm93cmFwIiwiVEQ6OnJvd3NwYW4iLCJU
-RDo6c2NvcGUiLCJURDo6dmFsaWduIiwiVEQ6OndpZHRoIiwiVEVYVEFSRUE6OmFjY2Vzc2tleSIsIlRF
-WFRBUkVBOjphdXRvY29tcGxldGUiLCJURVhUQVJFQTo6Y29scyIsIlRFWFRBUkVBOjpkaXNhYmxlZCIs
-IlRFWFRBUkVBOjppbnB1dG1vZGUiLCJURVhUQVJFQTo6bmFtZSIsIlRFWFRBUkVBOjpwbGFjZWhvbGRl
-ciIsIlRFWFRBUkVBOjpyZWFkb25seSIsIlRFWFRBUkVBOjpyZXF1aXJlZCIsIlRFWFRBUkVBOjpyb3dz
-IiwiVEVYVEFSRUE6OnRhYmluZGV4IiwiVEVYVEFSRUE6OndyYXAiLCJURk9PVDo6YWxpZ24iLCJURk9P
-VDo6Y2hhciIsIlRGT09UOjpjaGFyb2ZmIiwiVEZPT1Q6OnZhbGlnbiIsIlRIOjphYmJyIiwiVEg6OmFs
-aWduIiwiVEg6OmF4aXMiLCJUSDo6Ymdjb2xvciIsIlRIOjpjaGFyIiwiVEg6OmNoYXJvZmYiLCJUSDo6
-Y29sc3BhbiIsIlRIOjpoZWFkZXJzIiwiVEg6OmhlaWdodCIsIlRIOjpub3dyYXAiLCJUSDo6cm93c3Bh
-biIsIlRIOjpzY29wZSIsIlRIOjp2YWxpZ24iLCJUSDo6d2lkdGgiLCJUSEVBRDo6YWxpZ24iLCJUSEVB
-RDo6Y2hhciIsIlRIRUFEOjpjaGFyb2ZmIiwiVEhFQUQ6OnZhbGlnbiIsIlRSOjphbGlnbiIsIlRSOjpi
-Z2NvbG9yIiwiVFI6OmNoYXIiLCJUUjo6Y2hhcm9mZiIsIlRSOjp2YWxpZ24iLCJUUkFDSzo6ZGVmYXVs
-dCIsIlRSQUNLOjpraW5kIiwiVFJBQ0s6OmxhYmVsIiwiVFJBQ0s6OnNyY2xhbmciLCJVTDo6Y29tcGFj
-dCIsIlVMOjp0eXBlIiwiVklERU86OmNvbnRyb2xzIiwiVklERU86OmhlaWdodCIsIlZJREVPOjpsb29w
-IiwiVklERU86Om1lZGlhZ3JvdXAiLCJWSURFTzo6bXV0ZWQiLCJWSURFTzo6cHJlbG9hZCIsIlZJREVP
-Ojp3aWR0aCJdKSx0LmkpCkMuVkM9SC5WTShzKFswLDAsNjU0OTAsNDUwNTUsNjU1MzUsMzQ4MTUsNjU1
-MzQsMTg0MzFdKSx0LlYpCkMubUs9SC5WTShzKFswLDAsMjY2MjQsMTAyMyw2NTUzNCwyMDQ3LDY1NTM0
-LDIwNDddKSx0LlYpCkMuU3E9SC5WTShzKFsiSEVBRCIsIkFSRUEiLCJCQVNFIiwiQkFTRUZPTlQiLCJC
-UiIsIkNPTCIsIkNPTEdST1VQIiwiRU1CRUQiLCJGUkFNRSIsIkZSQU1FU0VUIiwiSFIiLCJJTUFHRSIs
-IklNRyIsIklOUFVUIiwiSVNJTkRFWCIsIkxJTksiLCJNRVRBIiwiUEFSQU0iLCJTT1VSQ0UiLCJTVFlM
-RSIsIlRJVExFIiwiV0JSIl0pLHQuaSkKQy5oVT1ILlZNKHMoW10pLHQuYikKQy5kbj1ILlZNKHMoW10p
-LEguTjAoImpkPExMKj4iKSkKQy54RD1ILlZNKHMoW10pLHQuaSkKQy50bz1ILlZNKHMoWzAsMCwzMjcy
-MiwxMjI4Nyw2NTUzNCwzNDgxNSw2NTUzNCwxODQzMV0pLHQuVikKQy5yaz1ILlZNKHMoW0MuQWQsQy5u
-ZSxDLm15LEMucngsQy53VixDLmZSXSksSC5OMCgiamQ8SDcqPiIpKQpDLkYzPUguVk0ocyhbMCwwLDI0
-NTc2LDEwMjMsNjU1MzQsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuZWE9SC5WTShzKFswLDAsMzI3
-NTQsMTEyNjMsNjU1MzQsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuWko9SC5WTShzKFswLDAsMzI3
-MjIsMTIyODcsNjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuV2Q9SC5WTShzKFswLDAsNjU0
-OTAsMTIyODcsNjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuUXg9SC5WTShzKFsiYmluZCIs
-ImlmIiwicmVmIiwicmVwZWF0Iiwic3ludGF4Il0pLHQuaSkKQy5CST1ILlZNKHMoWyJBOjpocmVmIiwi
-QVJFQTo6aHJlZiIsIkJMT0NLUVVPVEU6OmNpdGUiLCJCT0RZOjpiYWNrZ3JvdW5kIiwiQ09NTUFORDo6
-aWNvbiIsIkRFTDo6Y2l0ZSIsIkZPUk06OmFjdGlvbiIsIklNRzo6c3JjIiwiSU5QVVQ6OnNyYyIsIklO
-Uzo6Y2l0ZSIsIlE6OmNpdGUiLCJWSURFTzo6cG9zdGVyIl0pLHQuaSkKQy5EeD1uZXcgSC5MUCgwLHt9
-LEMueEQsSC5OMCgiTFA8cVUqLHpNPGo4Kj4qPiIpKQpDLkNNPW5ldyBILkxQKDAse30sQy54RCxILk4w
-KCJMUDxxVSoscVUqPiIpKQpDLmlIPUguVk0ocyhbXSksSC5OMCgiamQ8R0QqPiIpKQpDLldPPW5ldyBI
-LkxQKDAse30sQy5pSCxILk4wKCJMUDxHRCosQD4iKSkKQy5ZMj1uZXcgTC5POSgiTmF2aWdhdGlvblRy
-ZWVOb2RlVHlwZS5kaXJlY3RvcnkiKQpDLnJmPW5ldyBMLk85KCJOYXZpZ2F0aW9uVHJlZU5vZGVUeXBl
-LmZpbGUiKQpDLlRlPW5ldyBILnd2KCJjYWxsIikKQy5vRT1uZXcgUC5HWSghMSkKQy53UT1uZXcgUC5G
-eShudWxsLDIpfSkoKTsoZnVuY3Rpb24gc3RhdGljRmllbGRzKCl7JC56bT1udWxsCiQueWo9MAokLm1K
-PW51bGwKJC5QND1udWxsCiQuTkY9bnVsbAokLlRYPW51bGwKJC54Nz1udWxsCiQubnc9bnVsbAokLnZ2
-PW51bGwKJC5Cdj1udWxsCiQuUzY9bnVsbAokLms4PW51bGwKJC5tZz1udWxsCiQuVUQ9ITEKJC5YMz1D
-Lk5VCiQueGc9SC5WTShbXSxILk4wKCJqZDxNaD4iKSkKJC54bz1udWxsCiQuQk89bnVsbAokLmx0PW51
-bGwKJC5FVT1udWxsCiQub3I9UC5GbCh0Lk4sdC5ZKQokLklSPW51bGwKJC5JNj1udWxsCiQuRmY9bnVs
-bH0pKCk7KGZ1bmN0aW9uIGxhenlJbml0aWFsaXplcnMoKXt2YXIgcz1odW5rSGVscGVycy5sYXp5Rmlu
-YWwscj1odW5rSGVscGVycy5sYXp5T2xkCnMoJCwiZmEiLCJ3IixmdW5jdGlvbigpe3JldHVybiBILlln
-KCJfJGRhcnRfZGFydENsb3N1cmUiKX0pCnMoJCwiVTIiLCJTbiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5j
-TShILlM3KHsKdG9TdHJpbmc6ZnVuY3Rpb24oKXtyZXR1cm4iJHJlY2VpdmVyJCJ9fSkpfSkKcygkLCJ4
-cSIsImxxIixmdW5jdGlvbigpe3JldHVybiBILmNNKEguUzcoeyRtZXRob2QkOm51bGwsCnRvU3RyaW5n
-OmZ1bmN0aW9uKCl7cmV0dXJuIiRyZWNlaXZlciQifX0pKX0pCnMoJCwiUjEiLCJOOSIsZnVuY3Rpb24o
-KXtyZXR1cm4gSC5jTShILlM3KG51bGwpKX0pCnMoJCwiZk4iLCJpSSIsZnVuY3Rpb24oKXtyZXR1cm4g
-SC5jTShmdW5jdGlvbigpe3ZhciAkYXJndW1lbnRzRXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7bnVsbC4k
-bWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMo
-JCwicWkiLCJVTiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHZvaWQgMCkpfSkKcygkLCJyWiIs
-IlpoIixmdW5jdGlvbigpe3JldHVybiBILmNNKGZ1bmN0aW9uKCl7dmFyICRhcmd1bWVudHNFeHByJD0i
-JGFyZ3VtZW50cyQiCnRyeXsodm9pZCAwKS4kbWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNhdGNoKHEp
-e3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwia3EiLCJyTiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5j
-TShILk1qKG51bGwpKX0pCnMoJCwidHQiLCJjMyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlv
-bigpe3RyeXtudWxsLiRtZXRob2QkfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwi
-ZHQiLCJISyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILk1qKHZvaWQgMCkpfSkKcygkLCJBNyIsInIx
-IixmdW5jdGlvbigpe3JldHVybiBILmNNKGZ1bmN0aW9uKCl7dHJ5eyh2b2lkIDApLiRtZXRob2QkfWNh
-dGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwiV2MiLCJ1dCIsZnVuY3Rpb24oKXtyZXR1
-cm4gUC5PaigpfSkKcygkLCJraCIsInJmIixmdW5jdGlvbigpe3JldHVybiBuZXcgUC54cigpLiQwKCl9
-KQpzKCQsImRIIiwiSEciLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBQLk56KCkuJDAoKX0pCnMoJCwiaGoi
-LCJWNyIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEludDhBcnJheShILlhGKEguVk0oWy0yLC0yLC0yLC0y
-LC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0y
-LC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0xLC0yLC0yLC0yLC0yLC0yLDYy
-LC0yLDYyLC0yLDYzLDUyLDUzLDU0LDU1LDU2LDU3LDU4LDU5LDYwLDYxLC0yLC0yLC0yLC0xLC0yLC0y
-LC0yLDAsMSwyLDMsNCw1LDYsNyw4LDksMTAsMTEsMTIsMTMsMTQsMTUsMTYsMTcsMTgsMTksMjAsMjEs
-MjIsMjMsMjQsMjUsLTIsLTIsLTIsLTIsNjMsLTIsMjYsMjcsMjgsMjksMzAsMzEsMzIsMzMsMzQsMzUs
-MzYsMzcsMzgsMzksNDAsNDEsNDIsNDMsNDQsNDUsNDYsNDcsNDgsNDksNTAsNTEsLTIsLTIsLTIsLTIs
-LTJdLHQuYSkpKX0pCnMoJCwiTTUiLCJ3USIsZnVuY3Rpb24oKXtyZXR1cm4gdHlwZW9mIHByb2Nlc3Mh
-PSJ1bmRlZmluZWQiJiZPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nLmNhbGwocHJvY2Vzcyk9PSJbb2Jq
-ZWN0IHByb2Nlc3NdIiYmcHJvY2Vzcy5wbGF0Zm9ybT09IndpbjMyIn0pCnMoJCwibWYiLCJ6NCIsZnVu
-Y3Rpb24oKXtyZXR1cm4gUC5udSgiXltcXC1cXC4wLTlBLVpfYS16fl0qJCIpfSkKcygkLCJPUSIsInZa
-IixmdW5jdGlvbigpe3JldHVybiBQLktOKCl9KQpzKCQsIlNDIiwiQU4iLGZ1bmN0aW9uKCl7cmV0dXJu
-IFAudE0oWyJBIiwiQUJCUiIsIkFDUk9OWU0iLCJBRERSRVNTIiwiQVJFQSIsIkFSVElDTEUiLCJBU0lE
-RSIsIkFVRElPIiwiQiIsIkJESSIsIkJETyIsIkJJRyIsIkJMT0NLUVVPVEUiLCJCUiIsIkJVVFRPTiIs
-IkNBTlZBUyIsIkNBUFRJT04iLCJDRU5URVIiLCJDSVRFIiwiQ09ERSIsIkNPTCIsIkNPTEdST1VQIiwi
-Q09NTUFORCIsIkRBVEEiLCJEQVRBTElTVCIsIkREIiwiREVMIiwiREVUQUlMUyIsIkRGTiIsIkRJUiIs
-IkRJViIsIkRMIiwiRFQiLCJFTSIsIkZJRUxEU0VUIiwiRklHQ0FQVElPTiIsIkZJR1VSRSIsIkZPTlQi
-LCJGT09URVIiLCJGT1JNIiwiSDEiLCJIMiIsIkgzIiwiSDQiLCJINSIsIkg2IiwiSEVBREVSIiwiSEdS
-T1VQIiwiSFIiLCJJIiwiSUZSQU1FIiwiSU1HIiwiSU5QVVQiLCJJTlMiLCJLQkQiLCJMQUJFTCIsIkxF
-R0VORCIsIkxJIiwiTUFQIiwiTUFSSyIsIk1FTlUiLCJNRVRFUiIsIk5BViIsIk5PQlIiLCJPTCIsIk9Q
-VEdST1VQIiwiT1BUSU9OIiwiT1VUUFVUIiwiUCIsIlBSRSIsIlBST0dSRVNTIiwiUSIsIlMiLCJTQU1Q
-IiwiU0VDVElPTiIsIlNFTEVDVCIsIlNNQUxMIiwiU09VUkNFIiwiU1BBTiIsIlNUUklLRSIsIlNUUk9O
-RyIsIlNVQiIsIlNVTU1BUlkiLCJTVVAiLCJUQUJMRSIsIlRCT0RZIiwiVEQiLCJURVhUQVJFQSIsIlRG
-T09UIiwiVEgiLCJUSEVBRCIsIlRJTUUiLCJUUiIsIlRSQUNLIiwiVFQiLCJVIiwiVUwiLCJWQVIiLCJW
-SURFTyIsIldCUiJdLHQuTil9KQpzKCQsIlg0IiwiaEciLGZ1bmN0aW9uKCl7cmV0dXJuIFAubnUoIl5c
-XFMrJCIpfSkKcygkLCJ3TyIsIm93IixmdW5jdGlvbigpe3JldHVybiBQLk5EKHNlbGYpfSkKcygkLCJr
-dCIsIlI4IixmdW5jdGlvbigpe3JldHVybiBILllnKCJfJGRhcnRfZGFydE9iamVjdCIpfSkKcygkLCJm
-SyIsImtJIixmdW5jdGlvbigpe3JldHVybiBmdW5jdGlvbiBEYXJ0T2JqZWN0KGEpe3RoaXMubz1hfX0p
-CnIoJCwicXQiLCJ6QiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFQubVEoKX0pCnIoJCwiT2wiLCJVRSIs
-ZnVuY3Rpb24oKXtyZXR1cm4gUC5oSyhDLm9sLmdtVyhXLngzKCkpLmhyZWYpLmdoWSgpLnEoMCwiYXV0
-aFRva2VuIil9KQpyKCQsImhUIiwieVAiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVj
-dG9yKCIuZWRpdC1saXN0IC5wYW5lbC1jb250ZW50Iil9KQpyKCQsIlc2IiwiaEwiLGZ1bmN0aW9uKCl7
-cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIuZWRpdC1wYW5lbCAucGFuZWwtY29udGVudCIpfSkK
-cigkLCJUUiIsIkRXIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiZm9vdGVy
-Iil9KQpyKCQsIkVZIiwiZmkiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCJo
-ZWFkZXIiKX0pCnIoJCwiYkEiLCJjMCIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0
-b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24iKX0pCnIoJCwidDAiLCJiTiIsZnVuY3Rpb24oKXty
-ZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24tbGFiZWwi
-KX0pCnIoJCwiYXYiLCJEOSIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiN1
-bml0LW5hbWUiKX0pCnIoJCwiZmUiLCJLRyIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEwuWEEoKX0pCnMo
-JCwiZW8iLCJuVSIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IE0ubEkoJC5IaygpKX0pCnMoJCwieXIiLCJi
-RCIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEUuT0YoUC5udSgiLyIpLFAubnUoIlteL10kIiksUC5udSgi
-Xi8iKSl9KQpzKCQsIk1rIiwiS2siLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBMLklWKFAubnUoIlsvXFxc
-XF0iKSxQLm51KCJbXi9cXFxcXSQiKSxQLm51KCJeKFxcXFxcXFxcW15cXFxcXStcXFxcW15cXFxcL10r
-fFthLXpBLVpdOlsvXFxcXF0pIiksUC5udSgiXlsvXFxcXF0oPyFbL1xcXFxdKSIpKX0pCnMoJCwiYWsi
-LCJFYiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEYucnUoUC5udSgiLyIpLFAubnUoIiheW2EtekEtWl1b
-LSsuYS16QS1aXFxkXSo6Ly98W14vXSkkIiksUC5udSgiW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly9b
-Xi9dKiIpLFAubnUoIl4vIikpfSkKcygkLCJscyIsIkhrIixmdW5jdGlvbigpe3JldHVybiBPLlJoKCl9
-KX0pKCk7KGZ1bmN0aW9uIG5hdGl2ZVN1cHBvcnQoKXshZnVuY3Rpb24oKXt2YXIgcz1mdW5jdGlvbihh
-KXt2YXIgbT17fQptW2FdPTEKcmV0dXJuIE9iamVjdC5rZXlzKGh1bmtIZWxwZXJzLmNvbnZlcnRUb0Zh
-c3RPYmplY3QobSkpWzBdfQp2LmdldElzb2xhdGVUYWc9ZnVuY3Rpb24oYSl7cmV0dXJuIHMoIl9fX2Rh
-cnRfIithK3YuaXNvbGF0ZVRhZyl9CnZhciByPSJfX19kYXJ0X2lzb2xhdGVfdGFnc18iCnZhciBxPU9i
-amVjdFtyXXx8KE9iamVjdFtyXT1PYmplY3QuY3JlYXRlKG51bGwpKQp2YXIgcD0iX1p4WXhYIgpmb3Io
-dmFyIG89MDs7bysrKXt2YXIgbj1zKHArIl8iK28rIl8iKQppZighKG4gaW4gcSkpe3Fbbl09MQp2Lmlz
-b2xhdGVUYWc9bgpicmVha319di5kaXNwYXRjaFByb3BlcnR5TmFtZT12LmdldElzb2xhdGVUYWcoImRp
-c3BhdGNoX3JlY29yZCIpfSgpCmh1bmtIZWxwZXJzLnNldE9yVXBkYXRlSW50ZXJjZXB0b3JzQnlUYWco
-e0RPTUVycm9yOkouR3YsTWVkaWFFcnJvcjpKLkd2LE5hdmlnYXRvcjpKLkd2LE5hdmlnYXRvckNvbmN1
-cnJlbnRIYXJkd2FyZTpKLkd2LE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOkouR3YsT3ZlcmNvbnN0cmFp
-bmVkRXJyb3I6Si5HdixQb3NpdGlvbkVycm9yOkouR3YsUmFuZ2U6Si5HdixTUUxFcnJvcjpKLkd2LERh
-dGFWaWV3OkguRVQsQXJyYXlCdWZmZXJWaWV3OkguRVQsRmxvYXQzMkFycmF5OkguRGcsRmxvYXQ2NEFy
-cmF5OkguRGcsSW50MTZBcnJheTpILnhqLEludDMyQXJyYXk6SC5kRSxJbnQ4QXJyYXk6SC5aQSxVaW50
-MTZBcnJheTpILmRULFVpbnQzMkFycmF5OkguUHEsVWludDhDbGFtcGVkQXJyYXk6SC5lRSxDYW52YXNQ
-aXhlbEFycmF5OkguZUUsVWludDhBcnJheTpILlY2LEhUTUxBdWRpb0VsZW1lbnQ6Vy5xRSxIVE1MQlJF
-bGVtZW50OlcucUUsSFRNTEJ1dHRvbkVsZW1lbnQ6Vy5xRSxIVE1MQ2FudmFzRWxlbWVudDpXLnFFLEhU
-TUxDb250ZW50RWxlbWVudDpXLnFFLEhUTUxETGlzdEVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUVsZW1lbnQ6
-Vy5xRSxIVE1MRGF0YUxpc3RFbGVtZW50OlcucUUsSFRNTERldGFpbHNFbGVtZW50OlcucUUsSFRNTERp
-YWxvZ0VsZW1lbnQ6Vy5xRSxIVE1MRGl2RWxlbWVudDpXLnFFLEhUTUxFbWJlZEVsZW1lbnQ6Vy5xRSxI
-VE1MRmllbGRTZXRFbGVtZW50OlcucUUsSFRNTEhSRWxlbWVudDpXLnFFLEhUTUxIZWFkRWxlbWVudDpX
-LnFFLEhUTUxIZWFkaW5nRWxlbWVudDpXLnFFLEhUTUxIdG1sRWxlbWVudDpXLnFFLEhUTUxJRnJhbWVF
-bGVtZW50OlcucUUsSFRNTEltYWdlRWxlbWVudDpXLnFFLEhUTUxJbnB1dEVsZW1lbnQ6Vy5xRSxIVE1M
-TElFbGVtZW50OlcucUUsSFRNTExhYmVsRWxlbWVudDpXLnFFLEhUTUxMZWdlbmRFbGVtZW50OlcucUUs
-SFRNTExpbmtFbGVtZW50OlcucUUsSFRNTE1hcEVsZW1lbnQ6Vy5xRSxIVE1MTWVkaWFFbGVtZW50Olcu
-cUUsSFRNTE1lbnVFbGVtZW50OlcucUUsSFRNTE1ldGFFbGVtZW50OlcucUUsSFRNTE1ldGVyRWxlbWVu
-dDpXLnFFLEhUTUxNb2RFbGVtZW50OlcucUUsSFRNTE9MaXN0RWxlbWVudDpXLnFFLEhUTUxPYmplY3RF
-bGVtZW50OlcucUUsSFRNTE9wdEdyb3VwRWxlbWVudDpXLnFFLEhUTUxPcHRpb25FbGVtZW50OlcucUUs
-SFRNTE91dHB1dEVsZW1lbnQ6Vy5xRSxIVE1MUGFyYW1FbGVtZW50OlcucUUsSFRNTFBpY3R1cmVFbGVt
-ZW50OlcucUUsSFRNTFByZUVsZW1lbnQ6Vy5xRSxIVE1MUHJvZ3Jlc3NFbGVtZW50OlcucUUsSFRNTFF1
-b3RlRWxlbWVudDpXLnFFLEhUTUxTY3JpcHRFbGVtZW50OlcucUUsSFRNTFNoYWRvd0VsZW1lbnQ6Vy5x
-RSxIVE1MU2xvdEVsZW1lbnQ6Vy5xRSxIVE1MU291cmNlRWxlbWVudDpXLnFFLEhUTUxTcGFuRWxlbWVu
-dDpXLnFFLEhUTUxTdHlsZUVsZW1lbnQ6Vy5xRSxIVE1MVGFibGVDYXB0aW9uRWxlbWVudDpXLnFFLEhU
-TUxUYWJsZUNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlRGF0YUNlbGxFbGVtZW50OlcucUUsSFRNTFRh
-YmxlSGVhZGVyQ2VsbEVsZW1lbnQ6Vy5xRSxIVE1MVGFibGVDb2xFbGVtZW50OlcucUUsSFRNTFRleHRB
-cmVhRWxlbWVudDpXLnFFLEhUTUxUaW1lRWxlbWVudDpXLnFFLEhUTUxUaXRsZUVsZW1lbnQ6Vy5xRSxI
-VE1MVHJhY2tFbGVtZW50OlcucUUsSFRNTFVMaXN0RWxlbWVudDpXLnFFLEhUTUxVbmtub3duRWxlbWVu
-dDpXLnFFLEhUTUxWaWRlb0VsZW1lbnQ6Vy5xRSxIVE1MRGlyZWN0b3J5RWxlbWVudDpXLnFFLEhUTUxG
-b250RWxlbWVudDpXLnFFLEhUTUxGcmFtZUVsZW1lbnQ6Vy5xRSxIVE1MRnJhbWVTZXRFbGVtZW50Olcu
-cUUsSFRNTE1hcnF1ZWVFbGVtZW50OlcucUUsSFRNTEVsZW1lbnQ6Vy5xRSxIVE1MQW5jaG9yRWxlbWVu
-dDpXLkdoLEhUTUxBcmVhRWxlbWVudDpXLmZZLEhUTUxCYXNlRWxlbWVudDpXLm5CLEJsb2I6Vy5BeixI
-VE1MQm9keUVsZW1lbnQ6Vy5RUCxDREFUQVNlY3Rpb246Vy5ueCxDaGFyYWN0ZXJEYXRhOlcubngsQ29t
-bWVudDpXLm54LFByb2Nlc3NpbmdJbnN0cnVjdGlvbjpXLm54LFRleHQ6Vy5ueCxDU1NTdHlsZURlY2xh
-cmF0aW9uOlcub0osTVNTdHlsZUNTU1Byb3BlcnRpZXM6Vy5vSixDU1MyUHJvcGVydGllczpXLm9KLFhN
-TERvY3VtZW50OlcuUUYsRG9jdW1lbnQ6Vy5RRixET01FeGNlcHRpb246Vy5OaCxET01JbXBsZW1lbnRh
-dGlvbjpXLmFlLERPTVJlY3RSZWFkT25seTpXLklCLERPTVRva2VuTGlzdDpXLm43LEVsZW1lbnQ6Vy5j
-dixBYm9ydFBheW1lbnRFdmVudDpXLmVhLEFuaW1hdGlvbkV2ZW50OlcuZWEsQW5pbWF0aW9uUGxheWJh
-Y2tFdmVudDpXLmVhLEFwcGxpY2F0aW9uQ2FjaGVFcnJvckV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNo
-Q2xpY2tFdmVudDpXLmVhLEJhY2tncm91bmRGZXRjaEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoRmFp
-bEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoZWRFdmVudDpXLmVhLEJlZm9yZUluc3RhbGxQcm9tcHRF
-dmVudDpXLmVhLEJlZm9yZVVubG9hZEV2ZW50OlcuZWEsQmxvYkV2ZW50OlcuZWEsQ2FuTWFrZVBheW1l
-bnRFdmVudDpXLmVhLENsaXBib2FyZEV2ZW50OlcuZWEsQ2xvc2VFdmVudDpXLmVhLEN1c3RvbUV2ZW50
-OlcuZWEsRGV2aWNlTW90aW9uRXZlbnQ6Vy5lYSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OlcuZWEsRXJy
-b3JFdmVudDpXLmVhLEV4dGVuZGFibGVFdmVudDpXLmVhLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6Vy5l
-YSxGZXRjaEV2ZW50OlcuZWEsRm9udEZhY2VTZXRMb2FkRXZlbnQ6Vy5lYSxGb3JlaWduRmV0Y2hFdmVu
-dDpXLmVhLEdhbWVwYWRFdmVudDpXLmVhLEhhc2hDaGFuZ2VFdmVudDpXLmVhLEluc3RhbGxFdmVudDpX
-LmVhLE1lZGlhRW5jcnlwdGVkRXZlbnQ6Vy5lYSxNZWRpYUtleU1lc3NhZ2VFdmVudDpXLmVhLE1lZGlh
-UXVlcnlMaXN0RXZlbnQ6Vy5lYSxNZWRpYVN0cmVhbUV2ZW50OlcuZWEsTWVkaWFTdHJlYW1UcmFja0V2
-ZW50OlcuZWEsTWVzc2FnZUV2ZW50OlcuZWEsTUlESUNvbm5lY3Rpb25FdmVudDpXLmVhLE1JRElNZXNz
-YWdlRXZlbnQ6Vy5lYSxNdXRhdGlvbkV2ZW50OlcuZWEsTm90aWZpY2F0aW9uRXZlbnQ6Vy5lYSxQYWdl
-VHJhbnNpdGlvbkV2ZW50OlcuZWEsUGF5bWVudFJlcXVlc3RFdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0
-VXBkYXRlRXZlbnQ6Vy5lYSxQb3BTdGF0ZUV2ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2
-YWlsYWJsZUV2ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6Vy5lYSxQcm9t
-aXNlUmVqZWN0aW9uRXZlbnQ6Vy5lYSxQdXNoRXZlbnQ6Vy5lYSxSVENEYXRhQ2hhbm5lbEV2ZW50Olcu
-ZWEsUlRDRFRNRlRvbmVDaGFuZ2VFdmVudDpXLmVhLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6Vy5l
-YSxSVENUcmFja0V2ZW50OlcuZWEsU2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDpXLmVhLFNlbnNv
-ckVycm9yRXZlbnQ6Vy5lYSxTcGVlY2hSZWNvZ25pdGlvbkVycm9yOlcuZWEsU3BlZWNoUmVjb2duaXRp
-b25FdmVudDpXLmVhLFNwZWVjaFN5bnRoZXNpc0V2ZW50OlcuZWEsU3RvcmFnZUV2ZW50OlcuZWEsU3lu
-Y0V2ZW50OlcuZWEsVHJhY2tFdmVudDpXLmVhLFRyYW5zaXRpb25FdmVudDpXLmVhLFdlYktpdFRyYW5z
-aXRpb25FdmVudDpXLmVhLFZSRGV2aWNlRXZlbnQ6Vy5lYSxWUkRpc3BsYXlFdmVudDpXLmVhLFZSU2Vz
-c2lvbkV2ZW50OlcuZWEsTW9qb0ludGVyZmFjZVJlcXVlc3RFdmVudDpXLmVhLFVTQkNvbm5lY3Rpb25F
-dmVudDpXLmVhLElEQlZlcnNpb25DaGFuZ2VFdmVudDpXLmVhLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50Olcu
-ZWEsT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2ZW50OlcuZWEsV2ViR0xDb250ZXh0RXZlbnQ6Vy5lYSxF
-dmVudDpXLmVhLElucHV0RXZlbnQ6Vy5lYSxTdWJtaXRFdmVudDpXLmVhLEV2ZW50VGFyZ2V0OlcuRDAs
-RmlsZTpXLmhILEhUTUxGb3JtRWxlbWVudDpXLmg0LEhpc3Rvcnk6Vy5icixIVE1MRG9jdW1lbnQ6Vy5W
-YixYTUxIdHRwUmVxdWVzdDpXLmZKLFhNTEh0dHBSZXF1ZXN0RXZlbnRUYXJnZXQ6Vy53YSxJbWFnZURh
-dGE6Vy5TZyxMb2NhdGlvbjpXLnc3LE1vdXNlRXZlbnQ6Vy5BaixEcmFnRXZlbnQ6Vy5BaixQb2ludGVy
-RXZlbnQ6Vy5BaixXaGVlbEV2ZW50OlcuQWosRG9jdW1lbnRGcmFnbWVudDpXLnVILFNoYWRvd1Jvb3Q6
-Vy51SCxEb2N1bWVudFR5cGU6Vy51SCxOb2RlOlcudUgsTm9kZUxpc3Q6Vy5CSCxSYWRpb05vZGVMaXN0
-OlcuQkgsSFRNTFBhcmFncmFwaEVsZW1lbnQ6Vy5TTixQcm9ncmVzc0V2ZW50OlcuZXcsUmVzb3VyY2VQ
-cm9ncmVzc0V2ZW50OlcuZXcsSFRNTFNlbGVjdEVsZW1lbnQ6Vy5scCxIVE1MVGFibGVFbGVtZW50Olcu
-VGIsSFRNTFRhYmxlUm93RWxlbWVudDpXLkl2LEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OlcuV1AsSFRN
-TFRlbXBsYXRlRWxlbWVudDpXLnlZLENvbXBvc2l0aW9uRXZlbnQ6Vy53NixGb2N1c0V2ZW50OlcudzYs
-S2V5Ym9hcmRFdmVudDpXLnc2LFRleHRFdmVudDpXLnc2LFRvdWNoRXZlbnQ6Vy53NixVSUV2ZW50Olcu
-dzYsV2luZG93OlcuSzUsRE9NV2luZG93OlcuSzUsRGVkaWNhdGVkV29ya2VyR2xvYmFsU2NvcGU6Vy5D
-bSxTZXJ2aWNlV29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxTaGFyZWRXb3JrZXJHbG9iYWxTY29wZTpXLkNt
-LFdvcmtlckdsb2JhbFNjb3BlOlcuQ20sQXR0cjpXLkNRLENsaWVudFJlY3Q6Vy53NCxET01SZWN0Olcu
-dzQsTmFtZWROb2RlTWFwOlcucmgsTW96TmFtZWRBdHRyTWFwOlcucmgsSURCS2V5UmFuZ2U6UC5oRixT
-VkdTY3JpcHRFbGVtZW50OlAubmQsU1ZHQUVsZW1lbnQ6UC5oaSxTVkdBbmltYXRlRWxlbWVudDpQLmhp
-LFNWR0FuaW1hdGVNb3Rpb25FbGVtZW50OlAuaGksU1ZHQW5pbWF0ZVRyYW5zZm9ybUVsZW1lbnQ6UC5o
-aSxTVkdBbmltYXRpb25FbGVtZW50OlAuaGksU1ZHQ2lyY2xlRWxlbWVudDpQLmhpLFNWR0NsaXBQYXRo
-RWxlbWVudDpQLmhpLFNWR0RlZnNFbGVtZW50OlAuaGksU1ZHRGVzY0VsZW1lbnQ6UC5oaSxTVkdEaXNj
-YXJkRWxlbWVudDpQLmhpLFNWR0VsbGlwc2VFbGVtZW50OlAuaGksU1ZHRkVCbGVuZEVsZW1lbnQ6UC5o
-aSxTVkdGRUNvbG9yTWF0cml4RWxlbWVudDpQLmhpLFNWR0ZFQ29tcG9uZW50VHJhbnNmZXJFbGVtZW50
-OlAuaGksU1ZHRkVDb21wb3NpdGVFbGVtZW50OlAuaGksU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQ6
-UC5oaSxTVkdGRURpZmZ1c2VMaWdodGluZ0VsZW1lbnQ6UC5oaSxTVkdGRURpc3BsYWNlbWVudE1hcEVs
-ZW1lbnQ6UC5oaSxTVkdGRURpc3RhbnRMaWdodEVsZW1lbnQ6UC5oaSxTVkdGRUZsb29kRWxlbWVudDpQ
-LmhpLFNWR0ZFRnVuY0FFbGVtZW50OlAuaGksU1ZHRkVGdW5jQkVsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNH
-RWxlbWVudDpQLmhpLFNWR0ZFRnVuY1JFbGVtZW50OlAuaGksU1ZHRkVHYXVzc2lhbkJsdXJFbGVtZW50
-OlAuaGksU1ZHRkVJbWFnZUVsZW1lbnQ6UC5oaSxTVkdGRU1lcmdlRWxlbWVudDpQLmhpLFNWR0ZFTWVy
-Z2VOb2RlRWxlbWVudDpQLmhpLFNWR0ZFTW9ycGhvbG9neUVsZW1lbnQ6UC5oaSxTVkdGRU9mZnNldEVs
-ZW1lbnQ6UC5oaSxTVkdGRVBvaW50TGlnaHRFbGVtZW50OlAuaGksU1ZHRkVTcGVjdWxhckxpZ2h0aW5n
-RWxlbWVudDpQLmhpLFNWR0ZFU3BvdExpZ2h0RWxlbWVudDpQLmhpLFNWR0ZFVGlsZUVsZW1lbnQ6UC5o
-aSxTVkdGRVR1cmJ1bGVuY2VFbGVtZW50OlAuaGksU1ZHRmlsdGVyRWxlbWVudDpQLmhpLFNWR0ZvcmVp
-Z25PYmplY3RFbGVtZW50OlAuaGksU1ZHR0VsZW1lbnQ6UC5oaSxTVkdHZW9tZXRyeUVsZW1lbnQ6UC5o
-aSxTVkdHcmFwaGljc0VsZW1lbnQ6UC5oaSxTVkdJbWFnZUVsZW1lbnQ6UC5oaSxTVkdMaW5lRWxlbWVu
-dDpQLmhpLFNWR0xpbmVhckdyYWRpZW50RWxlbWVudDpQLmhpLFNWR01hcmtlckVsZW1lbnQ6UC5oaSxT
-VkdNYXNrRWxlbWVudDpQLmhpLFNWR01ldGFkYXRhRWxlbWVudDpQLmhpLFNWR1BhdGhFbGVtZW50OlAu
-aGksU1ZHUGF0dGVybkVsZW1lbnQ6UC5oaSxTVkdQb2x5Z29uRWxlbWVudDpQLmhpLFNWR1BvbHlsaW5l
-RWxlbWVudDpQLmhpLFNWR1JhZGlhbEdyYWRpZW50RWxlbWVudDpQLmhpLFNWR1JlY3RFbGVtZW50OlAu
-aGksU1ZHU2V0RWxlbWVudDpQLmhpLFNWR1N0b3BFbGVtZW50OlAuaGksU1ZHU3R5bGVFbGVtZW50OlAu
-aGksU1ZHU1ZHRWxlbWVudDpQLmhpLFNWR1N3aXRjaEVsZW1lbnQ6UC5oaSxTVkdTeW1ib2xFbGVtZW50
-OlAuaGksU1ZHVFNwYW5FbGVtZW50OlAuaGksU1ZHVGV4dENvbnRlbnRFbGVtZW50OlAuaGksU1ZHVGV4
-dEVsZW1lbnQ6UC5oaSxTVkdUZXh0UGF0aEVsZW1lbnQ6UC5oaSxTVkdUZXh0UG9zaXRpb25pbmdFbGVt
-ZW50OlAuaGksU1ZHVGl0bGVFbGVtZW50OlAuaGksU1ZHVXNlRWxlbWVudDpQLmhpLFNWR1ZpZXdFbGVt
-ZW50OlAuaGksU1ZHR3JhZGllbnRFbGVtZW50OlAuaGksU1ZHQ29tcG9uZW50VHJhbnNmZXJGdW5jdGlv
-bkVsZW1lbnQ6UC5oaSxTVkdGRURyb3BTaGFkb3dFbGVtZW50OlAuaGksU1ZHTVBhdGhFbGVtZW50OlAu
-aGksU1ZHRWxlbWVudDpQLmhpfSkKaHVua0hlbHBlcnMuc2V0T3JVcGRhdGVMZWFmVGFncyh7RE9NRXJy
-b3I6dHJ1ZSxNZWRpYUVycm9yOnRydWUsTmF2aWdhdG9yOnRydWUsTmF2aWdhdG9yQ29uY3VycmVudEhh
-cmR3YXJlOnRydWUsTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6dHJ1ZSxPdmVyY29uc3RyYWluZWRFcnJv
-cjp0cnVlLFBvc2l0aW9uRXJyb3I6dHJ1ZSxSYW5nZTp0cnVlLFNRTEVycm9yOnRydWUsRGF0YVZpZXc6
-dHJ1ZSxBcnJheUJ1ZmZlclZpZXc6ZmFsc2UsRmxvYXQzMkFycmF5OnRydWUsRmxvYXQ2NEFycmF5OnRy
-dWUsSW50MTZBcnJheTp0cnVlLEludDMyQXJyYXk6dHJ1ZSxJbnQ4QXJyYXk6dHJ1ZSxVaW50MTZBcnJh
-eTp0cnVlLFVpbnQzMkFycmF5OnRydWUsVWludDhDbGFtcGVkQXJyYXk6dHJ1ZSxDYW52YXNQaXhlbEFy
-cmF5OnRydWUsVWludDhBcnJheTpmYWxzZSxIVE1MQXVkaW9FbGVtZW50OnRydWUsSFRNTEJSRWxlbWVu
-dDp0cnVlLEhUTUxCdXR0b25FbGVtZW50OnRydWUsSFRNTENhbnZhc0VsZW1lbnQ6dHJ1ZSxIVE1MQ29u
-dGVudEVsZW1lbnQ6dHJ1ZSxIVE1MRExpc3RFbGVtZW50OnRydWUsSFRNTERhdGFFbGVtZW50OnRydWUs
-SFRNTERhdGFMaXN0RWxlbWVudDp0cnVlLEhUTUxEZXRhaWxzRWxlbWVudDp0cnVlLEhUTUxEaWFsb2dF
-bGVtZW50OnRydWUsSFRNTERpdkVsZW1lbnQ6dHJ1ZSxIVE1MRW1iZWRFbGVtZW50OnRydWUsSFRNTEZp
-ZWxkU2V0RWxlbWVudDp0cnVlLEhUTUxIUkVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZEVsZW1lbnQ6dHJ1ZSxI
-VE1MSGVhZGluZ0VsZW1lbnQ6dHJ1ZSxIVE1MSHRtbEVsZW1lbnQ6dHJ1ZSxIVE1MSUZyYW1lRWxlbWVu
-dDp0cnVlLEhUTUxJbWFnZUVsZW1lbnQ6dHJ1ZSxIVE1MSW5wdXRFbGVtZW50OnRydWUsSFRNTExJRWxl
-bWVudDp0cnVlLEhUTUxMYWJlbEVsZW1lbnQ6dHJ1ZSxIVE1MTGVnZW5kRWxlbWVudDp0cnVlLEhUTUxM
-aW5rRWxlbWVudDp0cnVlLEhUTUxNYXBFbGVtZW50OnRydWUsSFRNTE1lZGlhRWxlbWVudDp0cnVlLEhU
-TUxNZW51RWxlbWVudDp0cnVlLEhUTUxNZXRhRWxlbWVudDp0cnVlLEhUTUxNZXRlckVsZW1lbnQ6dHJ1
-ZSxIVE1MTW9kRWxlbWVudDp0cnVlLEhUTUxPTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MT2JqZWN0RWxlbWVu
-dDp0cnVlLEhUTUxPcHRHcm91cEVsZW1lbnQ6dHJ1ZSxIVE1MT3B0aW9uRWxlbWVudDp0cnVlLEhUTUxP
-dXRwdXRFbGVtZW50OnRydWUsSFRNTFBhcmFtRWxlbWVudDp0cnVlLEhUTUxQaWN0dXJlRWxlbWVudDp0
-cnVlLEhUTUxQcmVFbGVtZW50OnRydWUsSFRNTFByb2dyZXNzRWxlbWVudDp0cnVlLEhUTUxRdW90ZUVs
-ZW1lbnQ6dHJ1ZSxIVE1MU2NyaXB0RWxlbWVudDp0cnVlLEhUTUxTaGFkb3dFbGVtZW50OnRydWUsSFRN
-TFNsb3RFbGVtZW50OnRydWUsSFRNTFNvdXJjZUVsZW1lbnQ6dHJ1ZSxIVE1MU3BhbkVsZW1lbnQ6dHJ1
-ZSxIVE1MU3R5bGVFbGVtZW50OnRydWUsSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MVGFi
-bGVDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZURhdGFDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZUhl
-YWRlckNlbGxFbGVtZW50OnRydWUsSFRNTFRhYmxlQ29sRWxlbWVudDp0cnVlLEhUTUxUZXh0QXJlYUVs
-ZW1lbnQ6dHJ1ZSxIVE1MVGltZUVsZW1lbnQ6dHJ1ZSxIVE1MVGl0bGVFbGVtZW50OnRydWUsSFRNTFRy
-YWNrRWxlbWVudDp0cnVlLEhUTUxVTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MVW5rbm93bkVsZW1lbnQ6dHJ1
-ZSxIVE1MVmlkZW9FbGVtZW50OnRydWUsSFRNTERpcmVjdG9yeUVsZW1lbnQ6dHJ1ZSxIVE1MRm9udEVs
-ZW1lbnQ6dHJ1ZSxIVE1MRnJhbWVFbGVtZW50OnRydWUsSFRNTEZyYW1lU2V0RWxlbWVudDp0cnVlLEhU
-TUxNYXJxdWVlRWxlbWVudDp0cnVlLEhUTUxFbGVtZW50OmZhbHNlLEhUTUxBbmNob3JFbGVtZW50OnRy
-dWUsSFRNTEFyZWFFbGVtZW50OnRydWUsSFRNTEJhc2VFbGVtZW50OnRydWUsQmxvYjpmYWxzZSxIVE1M
-Qm9keUVsZW1lbnQ6dHJ1ZSxDREFUQVNlY3Rpb246dHJ1ZSxDaGFyYWN0ZXJEYXRhOnRydWUsQ29tbWVu
-dDp0cnVlLFByb2Nlc3NpbmdJbnN0cnVjdGlvbjp0cnVlLFRleHQ6dHJ1ZSxDU1NTdHlsZURlY2xhcmF0
-aW9uOnRydWUsTVNTdHlsZUNTU1Byb3BlcnRpZXM6dHJ1ZSxDU1MyUHJvcGVydGllczp0cnVlLFhNTERv
-Y3VtZW50OnRydWUsRG9jdW1lbnQ6ZmFsc2UsRE9NRXhjZXB0aW9uOnRydWUsRE9NSW1wbGVtZW50YXRp
-b246dHJ1ZSxET01SZWN0UmVhZE9ubHk6ZmFsc2UsRE9NVG9rZW5MaXN0OnRydWUsRWxlbWVudDpmYWxz
-ZSxBYm9ydFBheW1lbnRFdmVudDp0cnVlLEFuaW1hdGlvbkV2ZW50OnRydWUsQW5pbWF0aW9uUGxheWJh
-Y2tFdmVudDp0cnVlLEFwcGxpY2F0aW9uQ2FjaGVFcnJvckV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNo
-Q2xpY2tFdmVudDp0cnVlLEJhY2tncm91bmRGZXRjaEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoRmFp
-bEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoZWRFdmVudDp0cnVlLEJlZm9yZUluc3RhbGxQcm9tcHRF
-dmVudDp0cnVlLEJlZm9yZVVubG9hZEV2ZW50OnRydWUsQmxvYkV2ZW50OnRydWUsQ2FuTWFrZVBheW1l
-bnRFdmVudDp0cnVlLENsaXBib2FyZEV2ZW50OnRydWUsQ2xvc2VFdmVudDp0cnVlLEN1c3RvbUV2ZW50
-OnRydWUsRGV2aWNlTW90aW9uRXZlbnQ6dHJ1ZSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OnRydWUsRXJy
-b3JFdmVudDp0cnVlLEV4dGVuZGFibGVFdmVudDp0cnVlLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6dHJ1
-ZSxGZXRjaEV2ZW50OnRydWUsRm9udEZhY2VTZXRMb2FkRXZlbnQ6dHJ1ZSxGb3JlaWduRmV0Y2hFdmVu
-dDp0cnVlLEdhbWVwYWRFdmVudDp0cnVlLEhhc2hDaGFuZ2VFdmVudDp0cnVlLEluc3RhbGxFdmVudDp0
-cnVlLE1lZGlhRW5jcnlwdGVkRXZlbnQ6dHJ1ZSxNZWRpYUtleU1lc3NhZ2VFdmVudDp0cnVlLE1lZGlh
-UXVlcnlMaXN0RXZlbnQ6dHJ1ZSxNZWRpYVN0cmVhbUV2ZW50OnRydWUsTWVkaWFTdHJlYW1UcmFja0V2
-ZW50OnRydWUsTWVzc2FnZUV2ZW50OnRydWUsTUlESUNvbm5lY3Rpb25FdmVudDp0cnVlLE1JRElNZXNz
-YWdlRXZlbnQ6dHJ1ZSxNdXRhdGlvbkV2ZW50OnRydWUsTm90aWZpY2F0aW9uRXZlbnQ6dHJ1ZSxQYWdl
-VHJhbnNpdGlvbkV2ZW50OnRydWUsUGF5bWVudFJlcXVlc3RFdmVudDp0cnVlLFBheW1lbnRSZXF1ZXN0
-VXBkYXRlRXZlbnQ6dHJ1ZSxQb3BTdGF0ZUV2ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2
-YWlsYWJsZUV2ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6dHJ1ZSxQcm9t
-aXNlUmVqZWN0aW9uRXZlbnQ6dHJ1ZSxQdXNoRXZlbnQ6dHJ1ZSxSVENEYXRhQ2hhbm5lbEV2ZW50OnRy
-dWUsUlRDRFRNRlRvbmVDaGFuZ2VFdmVudDp0cnVlLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6dHJ1
-ZSxSVENUcmFja0V2ZW50OnRydWUsU2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDp0cnVlLFNlbnNv
-ckVycm9yRXZlbnQ6dHJ1ZSxTcGVlY2hSZWNvZ25pdGlvbkVycm9yOnRydWUsU3BlZWNoUmVjb2duaXRp
-b25FdmVudDp0cnVlLFNwZWVjaFN5bnRoZXNpc0V2ZW50OnRydWUsU3RvcmFnZUV2ZW50OnRydWUsU3lu
-Y0V2ZW50OnRydWUsVHJhY2tFdmVudDp0cnVlLFRyYW5zaXRpb25FdmVudDp0cnVlLFdlYktpdFRyYW5z
-aXRpb25FdmVudDp0cnVlLFZSRGV2aWNlRXZlbnQ6dHJ1ZSxWUkRpc3BsYXlFdmVudDp0cnVlLFZSU2Vz
-c2lvbkV2ZW50OnRydWUsTW9qb0ludGVyZmFjZVJlcXVlc3RFdmVudDp0cnVlLFVTQkNvbm5lY3Rpb25F
-dmVudDp0cnVlLElEQlZlcnNpb25DaGFuZ2VFdmVudDp0cnVlLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OnRy
-dWUsT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2ZW50OnRydWUsV2ViR0xDb250ZXh0RXZlbnQ6dHJ1ZSxF
-dmVudDpmYWxzZSxJbnB1dEV2ZW50OmZhbHNlLFN1Ym1pdEV2ZW50OmZhbHNlLEV2ZW50VGFyZ2V0OmZh
-bHNlLEZpbGU6dHJ1ZSxIVE1MRm9ybUVsZW1lbnQ6dHJ1ZSxIaXN0b3J5OnRydWUsSFRNTERvY3VtZW50
-OnRydWUsWE1MSHR0cFJlcXVlc3Q6dHJ1ZSxYTUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0OmZhbHNlLElt
-YWdlRGF0YTp0cnVlLExvY2F0aW9uOnRydWUsTW91c2VFdmVudDp0cnVlLERyYWdFdmVudDp0cnVlLFBv
-aW50ZXJFdmVudDp0cnVlLFdoZWVsRXZlbnQ6dHJ1ZSxEb2N1bWVudEZyYWdtZW50OnRydWUsU2hhZG93
-Um9vdDp0cnVlLERvY3VtZW50VHlwZTp0cnVlLE5vZGU6ZmFsc2UsTm9kZUxpc3Q6dHJ1ZSxSYWRpb05v
-ZGVMaXN0OnRydWUsSFRNTFBhcmFncmFwaEVsZW1lbnQ6dHJ1ZSxQcm9ncmVzc0V2ZW50OnRydWUsUmVz
-b3VyY2VQcm9ncmVzc0V2ZW50OnRydWUsSFRNTFNlbGVjdEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVFbGVt
-ZW50OnRydWUsSFRNTFRhYmxlUm93RWxlbWVudDp0cnVlLEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OnRy
-dWUsSFRNTFRlbXBsYXRlRWxlbWVudDp0cnVlLENvbXBvc2l0aW9uRXZlbnQ6dHJ1ZSxGb2N1c0V2ZW50
-OnRydWUsS2V5Ym9hcmRFdmVudDp0cnVlLFRleHRFdmVudDp0cnVlLFRvdWNoRXZlbnQ6dHJ1ZSxVSUV2
-ZW50OmZhbHNlLFdpbmRvdzp0cnVlLERPTVdpbmRvdzp0cnVlLERlZGljYXRlZFdvcmtlckdsb2JhbFNj
-b3BlOnRydWUsU2VydmljZVdvcmtlckdsb2JhbFNjb3BlOnRydWUsU2hhcmVkV29ya2VyR2xvYmFsU2Nv
-cGU6dHJ1ZSxXb3JrZXJHbG9iYWxTY29wZTp0cnVlLEF0dHI6dHJ1ZSxDbGllbnRSZWN0OnRydWUsRE9N
-UmVjdDp0cnVlLE5hbWVkTm9kZU1hcDp0cnVlLE1vek5hbWVkQXR0ck1hcDp0cnVlLElEQktleVJhbmdl
-OnRydWUsU1ZHU2NyaXB0RWxlbWVudDp0cnVlLFNWR0FFbGVtZW50OnRydWUsU1ZHQW5pbWF0ZUVsZW1l
-bnQ6dHJ1ZSxTVkdBbmltYXRlTW90aW9uRWxlbWVudDp0cnVlLFNWR0FuaW1hdGVUcmFuc2Zvcm1FbGVt
-ZW50OnRydWUsU1ZHQW5pbWF0aW9uRWxlbWVudDp0cnVlLFNWR0NpcmNsZUVsZW1lbnQ6dHJ1ZSxTVkdD
-bGlwUGF0aEVsZW1lbnQ6dHJ1ZSxTVkdEZWZzRWxlbWVudDp0cnVlLFNWR0Rlc2NFbGVtZW50OnRydWUs
-U1ZHRGlzY2FyZEVsZW1lbnQ6dHJ1ZSxTVkdFbGxpcHNlRWxlbWVudDp0cnVlLFNWR0ZFQmxlbmRFbGVt
-ZW50OnRydWUsU1ZHRkVDb2xvck1hdHJpeEVsZW1lbnQ6dHJ1ZSxTVkdGRUNvbXBvbmVudFRyYW5zZmVy
-RWxlbWVudDp0cnVlLFNWR0ZFQ29tcG9zaXRlRWxlbWVudDp0cnVlLFNWR0ZFQ29udm9sdmVNYXRyaXhF
-bGVtZW50OnRydWUsU1ZHRkVEaWZmdXNlTGlnaHRpbmdFbGVtZW50OnRydWUsU1ZHRkVEaXNwbGFjZW1l
-bnRNYXBFbGVtZW50OnRydWUsU1ZHRkVEaXN0YW50TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVGbG9vZEVs
-ZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNBRWxlbWVudDp0cnVlLFNWR0ZFRnVuY0JFbGVtZW50OnRydWUsU1ZH
-RkVGdW5jR0VsZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNSRWxlbWVudDp0cnVlLFNWR0ZFR2F1c3NpYW5CbHVy
-RWxlbWVudDp0cnVlLFNWR0ZFSW1hZ2VFbGVtZW50OnRydWUsU1ZHRkVNZXJnZUVsZW1lbnQ6dHJ1ZSxT
-VkdGRU1lcmdlTm9kZUVsZW1lbnQ6dHJ1ZSxTVkdGRU1vcnBob2xvZ3lFbGVtZW50OnRydWUsU1ZHRkVP
-ZmZzZXRFbGVtZW50OnRydWUsU1ZHRkVQb2ludExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFU3BlY3VsYXJM
-aWdodGluZ0VsZW1lbnQ6dHJ1ZSxTVkdGRVNwb3RMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVRpbGVFbGVt
-ZW50OnRydWUsU1ZHRkVUdXJidWxlbmNlRWxlbWVudDp0cnVlLFNWR0ZpbHRlckVsZW1lbnQ6dHJ1ZSxT
-VkdGb3JlaWduT2JqZWN0RWxlbWVudDp0cnVlLFNWR0dFbGVtZW50OnRydWUsU1ZHR2VvbWV0cnlFbGVt
-ZW50OnRydWUsU1ZHR3JhcGhpY3NFbGVtZW50OnRydWUsU1ZHSW1hZ2VFbGVtZW50OnRydWUsU1ZHTGlu
-ZUVsZW1lbnQ6dHJ1ZSxTVkdMaW5lYXJHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdNYXJrZXJFbGVtZW50
-OnRydWUsU1ZHTWFza0VsZW1lbnQ6dHJ1ZSxTVkdNZXRhZGF0YUVsZW1lbnQ6dHJ1ZSxTVkdQYXRoRWxl
-bWVudDp0cnVlLFNWR1BhdHRlcm5FbGVtZW50OnRydWUsU1ZHUG9seWdvbkVsZW1lbnQ6dHJ1ZSxTVkdQ
-b2x5bGluZUVsZW1lbnQ6dHJ1ZSxTVkdSYWRpYWxHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdSZWN0RWxl
-bWVudDp0cnVlLFNWR1NldEVsZW1lbnQ6dHJ1ZSxTVkdTdG9wRWxlbWVudDp0cnVlLFNWR1N0eWxlRWxl
-bWVudDp0cnVlLFNWR1NWR0VsZW1lbnQ6dHJ1ZSxTVkdTd2l0Y2hFbGVtZW50OnRydWUsU1ZHU3ltYm9s
-RWxlbWVudDp0cnVlLFNWR1RTcGFuRWxlbWVudDp0cnVlLFNWR1RleHRDb250ZW50RWxlbWVudDp0cnVl
-LFNWR1RleHRFbGVtZW50OnRydWUsU1ZHVGV4dFBhdGhFbGVtZW50OnRydWUsU1ZHVGV4dFBvc2l0aW9u
-aW5nRWxlbWVudDp0cnVlLFNWR1RpdGxlRWxlbWVudDp0cnVlLFNWR1VzZUVsZW1lbnQ6dHJ1ZSxTVkdW
-aWV3RWxlbWVudDp0cnVlLFNWR0dyYWRpZW50RWxlbWVudDp0cnVlLFNWR0NvbXBvbmVudFRyYW5zZmVy
-RnVuY3Rpb25FbGVtZW50OnRydWUsU1ZHRkVEcm9wU2hhZG93RWxlbWVudDp0cnVlLFNWR01QYXRoRWxl
-bWVudDp0cnVlLFNWR0VsZW1lbnQ6ZmFsc2V9KQpILkxaLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJh
-eUJ1ZmZlclZpZXciCkguUkcuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5W
-UC4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILkRnLiRuYXRpdmVTdXBlcmNs
-YXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguV0IuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVm
-ZmVyVmlldyIKSC5aRy4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILlBnLiRu
-YXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXcifSkoKQpjb252ZXJ0QWxsVG9GYXN0T2Jq
-ZWN0KHcpCmNvbnZlcnRUb0Zhc3RPYmplY3QoJCk7KGZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBkb2N1bWVu
-dD09PSJ1bmRlZmluZWQiKXthKG51bGwpCnJldHVybn1pZih0eXBlb2YgZG9jdW1lbnQuY3VycmVudFNj
-cmlwdCE9InVuZGVmaW5lZCIpe2EoZG9jdW1lbnQuY3VycmVudFNjcmlwdCkKcmV0dXJufXZhciBzPWRv
-Y3VtZW50LnNjcmlwdHMKZnVuY3Rpb24gb25Mb2FkKGIpe2Zvcih2YXIgcT0wO3E8cy5sZW5ndGg7Kytx
-KXNbcV0ucmVtb3ZlRXZlbnRMaXN0ZW5lcigibG9hZCIsb25Mb2FkLGZhbHNlKQphKGIudGFyZ2V0KX1m
-b3IodmFyIHI9MDtyPHMubGVuZ3RoOysrcilzW3JdLmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLG9uTG9h
-ZCxmYWxzZSl9KShmdW5jdGlvbihhKXt2LmN1cnJlbnRTY3JpcHQ9YQp2YXIgcz1MLklxCmlmKHR5cGVv
-ZiBkYXJ0TWFpblJ1bm5lcj09PSJmdW5jdGlvbiIpZGFydE1haW5SdW5uZXIocyxbXSkKZWxzZSBzKFtd
-KX0pfSkoKQovLyMgc291cmNlTWFwcGluZ1VSTD1taWdyYXRpb24uanMubWFwCg==
+QUFBQUFBQUFBQUZGRkZGRkZGRkZGRkZGRkZHR0dHR0dHR0dHR0dHR0dHSEhISEhISEhISEhISEhISEhI
+SEhISEhISEhISUhISEpFRUJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQktDQ0NDQ0NDQ0NDQ0NE
+Q0xPTk5OTUVFRUVFRUVFRUVFIixzKSYzMQpoPWk8PTMyP3MmNjE2OTQ+Pj5xOihzJjYzfGg8PDYpPj4+
+MAppPUMueEIuVygiIFx4MDAwOlhFQ0NDQ0NOOmxEYiBceDAwMDpYRUNDQ0NDTnZsRGIgXHgwMDA6WEVD
+Q0NDQ046bERiIEFBQUFBXHgwMFx4MDBceDAwXHgwMFx4MDBBQUFBQTAwMDAwQUFBQUE6Ojo6OkFBQUFB
+R0cwMDBBQUFBQTAwS0tLQUFBQUFHOjo6OkFBQUFBOklJSUlBQUFBQTAwMFx4ODAwQUFBQUFceDAwXHgw
+MFx4MDBceDAwIEFBQUFBIixpK3EpCmlmKGk9PT0wKXtnLmErPUguTHcoaCkKaWYoZj09PWMpYnJlYWsg
+JGxhYmVsMCQwCmJyZWFrfWVsc2UgaWYoKGkmMSkhPT0wKXtpZihyKXN3aXRjaChpKXtjYXNlIDY5OmNh
+c2UgNjc6Zy5hKz1ILkx3KGopCmJyZWFrCmNhc2UgNjU6Zy5hKz1ILkx3KGopOy0tZgpicmVhawpkZWZh
+dWx0OnA9Zy5hKz1ILkx3KGopCmcuYT1wK0guTHcoaikKYnJlYWt9ZWxzZXtrLmI9aQprLmM9Zi0xCnJl
+dHVybiIifWk9MH1pZihmPT09YylicmVhayAkbGFiZWwwJDAKbz1mKzEKaWYoZjwwfHxmPj1lKXJldHVy
+biBILk9IKGEsZikKcz1hW2ZdfW89ZisxCmlmKGY8MHx8Zj49ZSlyZXR1cm4gSC5PSChhLGYpCnM9YVtm
+XQppZihzPDEyOCl7d2hpbGUoITApe2lmKCEobzxjKSl7bj1jCmJyZWFrfW09bysxCmlmKG88MHx8bz49
+ZSlyZXR1cm4gSC5PSChhLG8pCnM9YVtvXQppZihzPj0xMjgpe249bS0xCm89bQpicmVha31vPW19aWYo
+bi1mPDIwKWZvcihsPWY7bDxuOysrbCl7aWYobD49ZSlyZXR1cm4gSC5PSChhLGwpCmcuYSs9SC5Mdyhh
+W2xdKX1lbHNlIGcuYSs9UC5ITShhLGYsbikKaWYobj09PWMpYnJlYWsgJGxhYmVsMCQwCmY9b31lbHNl
+IGY9b31pZihkJiZpPjMyKWlmKHIpZy5hKz1ILkx3KGopCmVsc2V7ay5iPTc3CmsuYz1jCnJldHVybiIi
+fWsuYj1pCmsuYz1oCmU9Zy5hCnJldHVybiBlLmNoYXJDb2RlQXQoMCk9PTA/ZTplfX0KUC5XRi5wcm90
+b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQp0LmZvLmEoYSkKcz10aGlzLmIKcj10aGlz
+LmEKcy5hKz1yLmEKcT1zLmErPUguRWooYS5hKQpzLmE9cSsiOiAiCnMuYSs9UC5obChiKQpyLmE9Iiwg
+In0sCiRTOjQwfQpQLmlQLnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7aWYoYj09bnVsbClyZXR1
+cm4hMQpyZXR1cm4gYiBpbnN0YW5jZW9mIFAuaVAmJnRoaXMuYT09PWIuYSYmITB9LApnaU86ZnVuY3Rp
+b24oYSl7dmFyIHM9dGhpcy5hCnJldHVybihzXkMuam4ud0cocywzMCkpJjEwNzM3NDE4MjN9LAp3OmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1QLkdxKEgudEoocykpLHE9UC5oMChILk5TKHMpKSxwPVAuaDAo
+SC5qQShzKSksbz1QLmgwKEguSVgocykpLG49UC5oMChILmNoKHMpKSxtPVAuaDAoSC5KZChzKSksbD1Q
+LlZ4KEgubzEocykpLGs9cisiLSIrcSsiLSIrcCsiICIrbysiOiIrbisiOiIrbSsiLiIrbApyZXR1cm4g
+a319ClAuWFMucHJvdG90eXBlPXsKZ0lJOmZ1bmN0aW9uKCl7cmV0dXJuIEgudHModGhpcy4kdGhyb3du
+SnNFcnJvcil9fQpQLkM2LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCmlmKHMh
+PW51bGwpcmV0dXJuIkFzc2VydGlvbiBmYWlsZWQ6ICIrUC5obChzKQpyZXR1cm4iQXNzZXJ0aW9uIGZh
+aWxlZCJ9fQpQLkV6LnByb3RvdHlwZT17fQpQLkxLLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0
+dXJuIlRocm93IG9mIG51bGwuIn19ClAuYy5wcm90b3R5cGU9ewpnWjpmdW5jdGlvbigpe3JldHVybiJJ
+bnZhbGlkIGFyZ3VtZW50IisoIXRoaXMuYT8iKHMpIjoiIil9LApndTpmdW5jdGlvbigpe3JldHVybiIi
+fSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxwPXEuYyxvPXA9PW51bGw/IiI6IiAoIitwKyIp
+IixuPXEuZCxtPW49PW51bGw/IiI6IjogIitILkVqKG4pLGw9cS5nWigpK28rbQppZighcS5hKXJldHVy
+biBsCnM9cS5ndSgpCnI9UC5obChxLmIpCnJldHVybiBsK3MrIjogIityfX0KUC5iSi5wcm90b3R5cGU9
+ewpnWjpmdW5jdGlvbigpe3JldHVybiJSYW5nZUVycm9yIn0sCmd1OmZ1bmN0aW9uKCl7dmFyIHMscj10
+aGlzLmUscT10aGlzLmYKaWYocj09bnVsbClzPXEhPW51bGw/IjogTm90IGxlc3MgdGhhbiBvciBlcXVh
+bCB0byAiK0guRWoocSk6IiIKZWxzZSBpZihxPT1udWxsKXM9IjogTm90IGdyZWF0ZXIgdGhhbiBvciBl
+cXVhbCB0byAiK0guRWoocikKZWxzZSBpZihxPnIpcz0iOiBOb3QgaW4gaW5jbHVzaXZlIHJhbmdlICIr
+SC5FaihyKSsiLi4iK0guRWoocSkKZWxzZSBzPXE8cj8iOiBWYWxpZCB2YWx1ZSByYW5nZSBpcyBlbXB0
+eSI6IjogT25seSB2YWxpZCB2YWx1ZSBpcyAiK0guRWoocikKcmV0dXJuIHN9fQpQLmVZLnByb3RvdHlw
+ZT17CmdaOmZ1bmN0aW9uKCl7cmV0dXJuIlJhbmdlRXJyb3IifSwKZ3U6ZnVuY3Rpb24oKXt2YXIgcyxy
+PUgudVAodGhpcy5iKQppZih0eXBlb2YgciE9PSJudW1iZXIiKXJldHVybiByLkooKQppZihyPDApcmV0
+dXJuIjogaW5kZXggbXVzdCBub3QgYmUgbmVnYXRpdmUiCnM9dGhpcy5mCmlmKHM9PT0wKXJldHVybiI6
+IG5vIGluZGljZXMgYXJlIHZhbGlkIgpyZXR1cm4iOiBpbmRleCBzaG91bGQgYmUgbGVzcyB0aGFuICIr
+SC5FaihzKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmZ9fQpQLm1wLnByb3RvdHlwZT17Cnc6
+ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRoaXMsaj17fSxpPW5ldyBQLk0oIiIpCmou
+YT0iIgpzPWsuYwpmb3Iocj1zLmxlbmd0aCxxPTAscD0iIixvPSIiO3E8cjsrK3Esbz0iLCAiKXtuPXNb
+cV0KaS5hPXArbwpwPWkuYSs9UC5obChuKQpqLmE9IiwgIn1rLmQuSygwLG5ldyBQLldGKGosaSkpCm09
+UC5obChrLmEpCmw9aS53KDApCnI9Ik5vU3VjaE1ldGhvZEVycm9yOiBtZXRob2Qgbm90IGZvdW5kOiAn
+IitILkVqKGsuYi5hKSsiJ1xuUmVjZWl2ZXI6ICIrbSsiXG5Bcmd1bWVudHM6IFsiK2wrIl0iCnJldHVy
+biByfX0KUC51Yi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJVbnN1cHBvcnRlZCBvcGVy
+YXRpb246ICIrdGhpcy5hfX0KUC5kcy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
+YQpyZXR1cm4gcyE9bnVsbD8iVW5pbXBsZW1lbnRlZEVycm9yOiAiK3M6IlVuaW1wbGVtZW50ZWRFcnJv
+ciJ9fQpQLmxqLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkJhZCBzdGF0ZTogIit0aGlz
+LmF9fQpQLlVWLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCmlmKHM9PW51bGwp
+cmV0dXJuIkNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uIGR1cmluZyBpdGVyYXRpb24uIgpyZXR1cm4iQ29u
+Y3VycmVudCBtb2RpZmljYXRpb24gZHVyaW5nIGl0ZXJhdGlvbjogIitQLmhsKHMpKyIuIn19ClAuazUu
+cHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iT3V0IG9mIE1lbW9yeSJ9LApnSUk6ZnVuY3Rp
+b24oKXtyZXR1cm4gbnVsbH0sCiRpWFM6MX0KUC5LWS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3Jl
+dHVybiJTdGFjayBPdmVyZmxvdyJ9LApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4gbnVsbH0sCiRpWFM6MX0K
+UC50Ny5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcz09bnVsbD8i
+UmVhZGluZyBzdGF0aWMgdmFyaWFibGUgZHVyaW5nIGl0cyBpbml0aWFsaXphdGlvbiI6IlJlYWRpbmcg
+c3RhdGljIHZhcmlhYmxlICciK3MrIicgZHVyaW5nIGl0cyBpbml0aWFsaXphdGlvbiJ9fQpQLkNELnBy
+b3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkV4Y2VwdGlvbjogIit0aGlzLmF9LAokaVJ6OjF9
+ClAuYUUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgs
+Zz10aGlzLmEsZj1nIT1udWxsJiYiIiE9PWc/IkZvcm1hdEV4Y2VwdGlvbjogIitILkVqKGcpOiJGb3Jt
+YXRFeGNlcHRpb24iLGU9dGhpcy5jLGQ9dGhpcy5iCmlmKHR5cGVvZiBkPT0ic3RyaW5nIil7aWYoZSE9
+bnVsbClzPWU8MHx8ZT5kLmxlbmd0aAplbHNlIHM9ITEKaWYocyllPW51bGwKaWYoZT09bnVsbCl7aWYo
+ZC5sZW5ndGg+NzgpZD1DLnhCLk5qKGQsMCw3NSkrIi4uLiIKcmV0dXJuIGYrIlxuIitkfWZvcihyPTEs
+cT0wLHA9ITEsbz0wO288ZTsrK28pe249Qy54Qi5XKGQsbykKaWYobj09PTEwKXtpZihxIT09b3x8IXAp
+KytyCnE9bysxCnA9ITF9ZWxzZSBpZihuPT09MTMpeysrcgpxPW8rMQpwPSEwfX1mPXI+MT9mKygiIChh
+dCBsaW5lICIrcisiLCBjaGFyYWN0ZXIgIisoZS1xKzEpKyIpXG4iKTpmKygiIChhdCBjaGFyYWN0ZXIg
+IisoZSsxKSsiKVxuIikKbT1kLmxlbmd0aApmb3Iobz1lO288bTsrK28pe249Qy54Qi5PKGQsbykKaWYo
+bj09PTEwfHxuPT09MTMpe209bwpicmVha319aWYobS1xPjc4KWlmKGUtcTw3NSl7bD1xKzc1Cms9cQpq
+PSIiCmk9Ii4uLiJ9ZWxzZXtpZihtLWU8NzUpe2s9bS03NQpsPW0KaT0iIn1lbHNle2s9ZS0zNgpsPWUr
+MzYKaT0iLi4uIn1qPSIuLi4ifWVsc2V7bD1tCms9cQpqPSIiCmk9IiJ9aD1DLnhCLk5qKGQsayxsKQpy
+ZXR1cm4gZitqK2graSsiXG4iK0MueEIuVCgiICIsZS1rK2oubGVuZ3RoKSsiXlxuIn1lbHNlIHJldHVy
+biBlIT1udWxsP2YrKCIgKGF0IG9mZnNldCAiK0guRWooZSkrIikiKTpmfSwKJGlSejoxfQpQLmNYLnBy
+b3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguR0oodGhpcyxILkxoKHRoaXMpLkMoImNY
+LkUiKSxiKX0sCkUyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVybiBILksxKHRo
+aXMscy5LcShjKS5DKCIxKGNYLkUpIikuYShiKSxzLkMoImNYLkUiKSxjKX0sCmV2OmZ1bmN0aW9uKGEs
+Yil7dmFyIHM9SC5MaCh0aGlzKQpyZXR1cm4gbmV3IEguVTUodGhpcyxzLkMoImEyKGNYLkUpIikuYShi
+KSxzLkMoIlU1PGNYLkU+IikpfSwKdHQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gUC5ZMSh0aGlzLGIsSC5M
+aCh0aGlzKS5DKCJjWC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9LApn
+QTpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuZ20odGhpcykKZm9yKHM9MDtyLkYoKTspKytzCnJldHVy
+biBzfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdtKHRoaXMpLkYoKX0sCmdvcjpmdW5jdGlv
+bihhKXtyZXR1cm4hdGhpcy5nbDAodGhpcyl9LAplUjpmdW5jdGlvbihhLGIpe3JldHVybiBILmJLKHRo
+aXMsYixILkxoKHRoaXMpLkMoImNYLkUiKSl9LApncjg6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLmdt
+KHRoaXMpCmlmKCFyLkYoKSl0aHJvdyBILmIoSC5XcCgpKQpzPXIuZ2woKQppZihyLkYoKSl0aHJvdyBI
+LmIoSC5BbSgpKQpyZXR1cm4gc30sCkU6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKUC5rMShiLCJpbmRl
+eCIpCmZvcihzPXRoaXMuZ20odGhpcykscj0wO3MuRigpOyl7cT1zLmdsKCkKaWYoYj09PXIpcmV0dXJu
+IHE7KytyfXRocm93IEguYihQLkNmKGIsdGhpcywiaW5kZXgiLG51bGwscikpfSwKdzpmdW5jdGlvbihh
+KXtyZXR1cm4gUC5FUCh0aGlzLCIoIiwiKSIpfX0KUC5Bbi5wcm90b3R5cGU9e30KUC5OMy5wcm90b3R5
+cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJNYXBFbnRyeSgiK0guRWoodGhpcy5hKSsiOiAiK0guRWoo
+dGhpcy5iKSsiKSJ9fQpQLmM4LnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gUC5NaC5w
+cm90b3R5cGUuZ2lPLmNhbGwodGhpcyx0aGlzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIm51bGwifX0K
+UC5NaC5wcm90b3R5cGU9e2NvbnN0cnVjdG9yOlAuTWgsJGlNaDoxLApETjpmdW5jdGlvbihhLGIpe3Jl
+dHVybiB0aGlzPT09Yn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gSC5lUSh0aGlzKX0sCnc6ZnVuY3Rp
+b24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5saCh0aGlzKSkrIicifSwKZTc6ZnVuY3Rp
+b24oYSxiKXt0Lm8uYShiKQp0aHJvdyBILmIoUC5scih0aGlzLGIuZ1dhKCksYi5nbmQoKSxiLmdWbSgp
+KSl9LAp0b1N0cmluZzpmdW5jdGlvbigpe3JldHVybiB0aGlzLncodGhpcyl9fQpQLlpkLnByb3RvdHlw
+ZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIiJ9LAokaUd6OjF9ClAuTS5wcm90b3R5cGU9ewpnQTpmdW5j
+dGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJl
+dHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwKJGlCTDoxfQpQLm4xLnByb3RvdHlwZT17CiQyOmZ1
+bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5KLmEoYSkKSC5oKGIpCnM9Si5EMShiLCI9IikKaWYocz09
+PS0xKXtpZihiIT09IiIpYS5ZNSgwLFAua3UoYiwwLGIubGVuZ3RoLHRoaXMuYSwhMCksIiIpfWVsc2Ug
+aWYocyE9PTApe3I9Qy54Qi5OaihiLDAscykKcT1DLnhCLnluKGIscysxKQpwPXRoaXMuYQphLlk1KDAs
+UC5rdShyLDAsci5sZW5ndGgscCwhMCksUC5rdShxLDAscS5sZW5ndGgscCwhMCkpfXJldHVybiBhfSwK
+JFM6NDF9ClAuY1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxs
+ZWdhbCBJUHY0IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJFM6MjF9ClAuVkMucHJvdG90eXBlPXsK
+JDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxsZWdhbCBJUHY2IGFkZHJlc3MsICIrYSx0
+aGlzLmEsYikpfSwKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuJDIoYSxudWxsKX0sCiRTOjQ1fQpQ
+LkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYi1hPjQpdGhpcy5hLiQyKCJh
+biBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFpbiBhIG1heGltdW0gb2YgNCBoZXggZGlnaXRzIixhKQpz
+PVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwxNikKaWYoczwwfHxzPjY1NTM1KXRoaXMuYS4kMigiZWFj
+aCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIG9mIGAweDAuLjB4RkZGRmAiLGEpCnJldHVybiBzfSwK
+JFM6NTJ9ClAuRG4ucHJvdG90eXBlPXsKZ25EOmZ1bmN0aW9uKCl7dmFyIHMscixxLHA9dGhpcyxvPXAu
+eAppZihvPT09JCl7bz1wLmEKcz1vLmxlbmd0aCE9PTA/bysiOiI6IiIKcj1wLmMKcT1yPT1udWxsCmlm
+KCFxfHxvPT09ImZpbGUiKXtvPXMrIi8vIgpzPXAuYgppZihzLmxlbmd0aCE9PTApbz1vK3MrIkAiCmlm
+KCFxKW8rPXIKcz1wLmQKaWYocyE9bnVsbClvPW8rIjoiK0guRWoocyl9ZWxzZSBvPXMKbys9cC5lCnM9
+cC5mCmlmKHMhPW51bGwpbz1vKyI/IitzCnM9cC5yCmlmKHMhPW51bGwpbz1vKyIjIitzCm89by5jaGFy
+Q29kZUF0KDApPT0wP286bwppZihwLng9PT0kKXAueD1vCmVsc2Ugbz1ILnYoSC5qKCJfdGV4dCIpKX1y
+ZXR1cm4gb30sCmdGajpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIueQppZihxPT09JCl7cz1yLmUK
+aWYocy5sZW5ndGghPT0wJiZDLnhCLlcocywwKT09PTQ3KXM9Qy54Qi55bihzLDEpCnE9cy5sZW5ndGg9
+PT0wP0MueEQ6UC5BRihuZXcgSC5sSihILlFJKHMuc3BsaXQoIi8iKSx0LnMpLHQuZE8uYShQLlBIKCkp
+LHQuZG8pLHQuTikKaWYoci55PT09JClyLnNLcChxKQplbHNlIHE9SC52KEguaigicGF0aFNlZ21lbnRz
+IikpfXJldHVybiBxfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1zLnoKaWYocj09PSQpe3I9
+Si5oZihzLmduRCgpKQppZihzLno9PT0kKXMuej1yCmVsc2Ugcj1ILnYoSC5qKCJoYXNoQ29kZSIpKX1y
+ZXR1cm4gcn0sCmdoWTpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLlEKaWYocj09PSQpe3I9cy5mCnI9
+bmV3IFAuR2ooUC5XWChyPT1udWxsPyIiOnIpLHQuZHcpCmlmKHMuUT09PSQpcy5zTk0ocikKZWxzZSBy
+PUgudihILmooInF1ZXJ5UGFyYW1ldGVycyIpKX1yZXR1cm4gcn0sCmdrdTpmdW5jdGlvbigpe3JldHVy
+biB0aGlzLmJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCmlmKHM9PW51bGwpcmV0dXJuIiIK
+aWYoQy54Qi5uQyhzLCJbIikpcmV0dXJuIEMueEIuTmoocywxLHMubGVuZ3RoLTEpCnJldHVybiBzfSwK
+Z3RwOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZApyZXR1cm4gcz09bnVsbD9QLndLKHRoaXMuYSk6c30s
+Cmd0UDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuZgpyZXR1cm4gcz09bnVsbD8iIjpzfSwKZ0thOmZ1bmN0
+aW9uKCl7dmFyIHM9dGhpcy5yCnJldHVybiBzPT1udWxsPyIiOnN9LApoQjpmdW5jdGlvbihhKXt2YXIg
+cz10aGlzLmEKaWYoYS5sZW5ndGghPT1zLmxlbmd0aClyZXR1cm4hMQpyZXR1cm4gUC5OUihhLHMpfSwK
+bm06ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaj10aGlzCnQuYzkuYShiKQpzPWou
+YQpyPXM9PT0iZmlsZSIKcT1qLmIKcD1qLmQKbz1qLmMKaWYoIShvIT1udWxsKSlvPXEubGVuZ3RoIT09
+MHx8cCE9bnVsbHx8cj8iIjpudWxsCm49ai5lCmlmKCFyKW09byE9bnVsbCYmbi5sZW5ndGghPT0wCmVs
+c2UgbT0hMAppZihtJiYhQy54Qi5uQyhuLCIvIikpbj0iLyIrbgpsPW4Kaz1QLmxlKG51bGwsMCwwLGIp
+CnJldHVybiBQLkNnKHMscSxvLHAsbCxrLGoucil9LApKaDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxw
+LG8sbgpmb3Iocz0wLHI9MDtDLnhCLlFpKGIsIi4uLyIscik7KXtyKz0zOysrc31xPUMueEIuY24oYSwi
+LyIpCndoaWxlKCEwKXtpZighKHE+MCYmcz4wKSlicmVhawpwPUMueEIuUGsoYSwiLyIscS0xKQppZihw
+PDApYnJlYWsKbz1xLXAKbj1vIT09MgppZighbnx8bz09PTMpaWYoQy54Qi5PKGEscCsxKT09PTQ2KW49
+IW58fEMueEIuTyhhLHArMik9PT00NgplbHNlIG49ITEKZWxzZSBuPSExCmlmKG4pYnJlYWs7LS1zCnE9
+cH1yZXR1cm4gQy54Qi5pNyhhLHErMSxudWxsLEMueEIueW4oYixyLTMqcykpfSwKWkk6ZnVuY3Rpb24o
+YSl7cmV0dXJuIHRoaXMubVMoUC5oSyhhKSl9LAptUzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4s
+bSxsLGssaixpPXRoaXMsaD1udWxsCmlmKGEuZ0ZpKCkubGVuZ3RoIT09MCl7cz1hLmdGaSgpCmlmKGEu
+Z2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9YS5neEEoKT9hLmd0cChhKTpofWVsc2V7cD1oCnE9
+cApyPSIifW89UC54ZShhLmdJaShhKSkKbj1hLmdRRCgpP2EuZ3RQKCk6aH1lbHNle3M9aS5hCmlmKGEu
+Z2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9UC53QihhLmd4QSgpP2EuZ3RwKGEpOmgscykKbz1Q
+LnhlKGEuZ0lpKGEpKQpuPWEuZ1FEKCk/YS5ndFAoKTpofWVsc2V7cj1pLmIKcT1pLmMKcD1pLmQKbz1p
+LmUKaWYoYS5nSWkoYSk9PT0iIiluPWEuZ1FEKCk/YS5ndFAoKTppLmYKZWxzZXttPVAudWooaSxvKQpp
+ZihtPjApe2w9Qy54Qi5OaihvLDAsbSkKbz1hLmd0VCgpP2wrUC54ZShhLmdJaShhKSk6bCtQLnhlKGku
+SmgoQy54Qi55bihvLGwubGVuZ3RoKSxhLmdJaShhKSkpfWVsc2UgaWYoYS5ndFQoKSlvPVAueGUoYS5n
+SWkoYSkpCmVsc2UgaWYoby5sZW5ndGg9PT0wKWlmKHE9PW51bGwpbz1zLmxlbmd0aD09PTA/YS5nSWko
+YSk6UC54ZShhLmdJaShhKSkKZWxzZSBvPVAueGUoIi8iK2EuZ0lpKGEpKQplbHNle2s9aS5KaChvLGEu
+Z0lpKGEpKQpqPXMubGVuZ3RoPT09MAppZighanx8cSE9bnVsbHx8Qy54Qi5uQyhvLCIvIikpbz1QLnhl
+KGspCmVsc2Ugbz1QLndGKGssIWp8fHEhPW51bGwpfW49YS5nUUQoKT9hLmd0UCgpOmh9fX1yZXR1cm4g
+UC5DZyhzLHIscSxwLG8sbixhLmdaOCgpP2EuZ0thKCk6aCl9LApnY2o6ZnVuY3Rpb24oKXtyZXR1cm4g
+dGhpcy5jIT1udWxsfSwKZ3hBOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZCE9bnVsbH0sCmdRRDpmdW5j
+dGlvbigpe3JldHVybiB0aGlzLmYhPW51bGx9LApnWjg6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yIT1u
+dWxsfSwKZ3RUOmZ1bmN0aW9uKCl7cmV0dXJuIEMueEIubkModGhpcy5lLCIvIil9LAp0NDpmdW5jdGlv
+bigpe3ZhciBzLHI9dGhpcyxxPXIuYQppZihxIT09IiImJnEhPT0iZmlsZSIpdGhyb3cgSC5iKFAuTDQo
+IkNhbm5vdCBleHRyYWN0IGEgZmlsZSBwYXRoIGZyb20gYSAiK3ErIiBVUkkiKSkKcT1yLmYKaWYoKHE9
+PW51bGw/IiI6cSkhPT0iIil0aHJvdyBILmIoUC5MNCh1LmkpKQpxPXIucgppZigocT09bnVsbD8iIjpx
+KSE9PSIiKXRocm93IEguYihQLkw0KHUubCkpCnE9JC53USgpCmlmKEgub1QocSkpcT1QLm1uKHIpCmVs
+c2V7aWYoci5jIT1udWxsJiZyLmdKZihyKSE9PSIiKUgudihQLkw0KHUuaikpCnM9ci5nRmooKQpQLmtF
+KHMsITEpCnE9UC5sKEMueEIubkMoci5lLCIvIik/Ii8iOiIiLHMsIi8iKQpxPXEuY2hhckNvZGVBdCgw
+KT09MD9xOnF9cmV0dXJuIHF9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmduRCgpfSwKRE46ZnVu
+Y3Rpb24oYSxiKXt2YXIgcyxyLHE9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHE9PT1iKXJldHVy
+biEwCmlmKHQuZEQuYihiKSlpZihxLmE9PT1iLmdGaSgpKWlmKHEuYyE9bnVsbD09PWIuZ2NqKCkpaWYo
+cS5iPT09Yi5na3UoKSlpZihxLmdKZihxKT09PWIuZ0pmKGIpKWlmKHEuZ3RwKHEpPT09Yi5ndHAoYikp
+aWYocS5lPT09Yi5nSWkoYikpe3M9cS5mCnI9cz09bnVsbAppZighcj09PWIuZ1FEKCkpe2lmKHIpcz0i
+IgppZihzPT09Yi5ndFAoKSl7cz1xLnIKcj1zPT1udWxsCmlmKCFyPT09Yi5nWjgoKSl7aWYocilzPSIi
+CnM9cz09PWIuZ0thKCl9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSExCmVsc2Ug
+cz0hMQplbHNlIHM9ITEKZWxzZSBzPSExCmVsc2Ugcz0hMQplbHNlIHM9ITEKZWxzZSBzPSExCnJldHVy
+biBzfSwKc0twOmZ1bmN0aW9uKGEpe3RoaXMueT10LmJrLmEoYSl9LApzTk06ZnVuY3Rpb24oYSl7dGhp
+cy5RPXQuY1ouYShhKX0sCiRpaUQ6MSwKZ0ZpOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX0sCmdJaTpm
+dW5jdGlvbihhKXtyZXR1cm4gdGhpcy5lfX0KUC5SWi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXty
+ZXR1cm4gUC5lUChDLlpKLEguaChhKSxDLnhNLCExKX0sCiRTOjV9ClAuTUUucHJvdG90eXBlPXsKJDI6
+ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmIscj10aGlzLmEKcy5hKz1yLmEKci5hPSImIgpyPXMuYSs9
+SC5FaihQLmVQKEMuRjMsYSxDLnhNLCEwKSkKaWYoYiE9bnVsbCYmYi5sZW5ndGghPT0wKXtzLmE9cisi
+PSIKcy5hKz1ILkVqKFAuZVAoQy5GMyxiLEMueE0sITApKX19LAokUzoyMn0KUC55NS5wcm90b3R5cGU9
+ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC5oKGEpCmlmKGI9PW51bGx8fHR5cGVvZiBiPT0ic3Ry
+aW5nIil0aGlzLmEuJDIoYSxILmsoYikpCmVsc2UgZm9yKHM9Si5JVCh0LnUuYShiKSkscj10aGlzLmE7
+cy5GKCk7KXIuJDIoYSxILmgocy5nbCgpKSl9LAokUzoxM30KUC5QRS5wcm90b3R5cGU9ewpnbFI6ZnVu
+Y3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1udWxsLG09by5jCmlmKG09PW51bGwpe209by5iCmlm
+KDA+PW0ubGVuZ3RoKXJldHVybiBILk9IKG0sMCkKcz1vLmEKbT1tWzBdKzEKcj1DLnhCLlhVKHMsIj8i
+LG0pCnE9cy5sZW5ndGgKaWYocj49MCl7cD1QLlBJKHMscisxLHEsQy5WQywhMSkKcT1yfWVsc2UgcD1u
+Cm09by5jPW5ldyBQLnFlKCJkYXRhIiwiIixuLG4sUC5QSShzLG0scSxDLldkLCExKSxwLG4pfXJldHVy
+biBtfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuYgppZigwPj1yLmxlbmd0aClyZXR1cm4gSC5P
+SChyLDApCnM9dGhpcy5hCnJldHVybiByWzBdPT09LTE/ImRhdGE6IitzOnN9fQpQLnlJLnByb3RvdHlw
+ZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5hCmlmKGE+PXMubGVuZ3RoKXJldHVybiBILk9I
+KHMsYSkKcz1zW2FdCkMuTkEuZHUocywwLDk2LGIpCnJldHVybiBzfSwKJFM6MjN9ClAuYzYucHJvdG90
+eXBlPXsKJDM6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpmb3Iocz1iLmxlbmd0aCxyPTA7cjxzOysr
+cil7cT1DLnhCLlcoYixyKV45NgppZihxPj05NilyZXR1cm4gSC5PSChhLHEpCmFbcV09Y319LAokUzox
+NH0KUC5xZC5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxCmZvcihzPUMueEIu
+VyhiLDApLHI9Qy54Qi5XKGIsMSk7czw9cjsrK3Mpe3E9KHNeOTYpPj4+MAppZihxPj05NilyZXR1cm4g
+SC5PSChhLHEpCmFbcV09Y319LAokUzoxNH0KUC5VZi5wcm90b3R5cGU9ewpnY2o6ZnVuY3Rpb24oKXty
+ZXR1cm4gdGhpcy5jPjB9LApneEE6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5jPjAmJnRoaXMuZCsxPHRo
+aXMuZX0sCmdRRDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmY8dGhpcy5yfSwKZ1o4OmZ1bmN0aW9uKCl7
+cmV0dXJuIHRoaXMucjx0aGlzLmEubGVuZ3RofSwKZ3RUOmZ1bmN0aW9uKCl7cmV0dXJuIEMueEIuUWko
+dGhpcy5hLCIvIix0aGlzLmUpfSwKZ0ZpOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy54CnJldHVybiBzPT1u
+dWxsP3RoaXMueD10aGlzLlUyKCk6c30sClUyOmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5iCmlm
+KHE8PTApcmV0dXJuIiIKcz1xPT09NAppZihzJiZDLnhCLm5DKHIuYSwiaHR0cCIpKXJldHVybiJodHRw
+IgppZihxPT09NSYmQy54Qi5uQyhyLmEsImh0dHBzIikpcmV0dXJuImh0dHBzIgppZihzJiZDLnhCLm5D
+KHIuYSwiZmlsZSIpKXJldHVybiJmaWxlIgppZihxPT09NyYmQy54Qi5uQyhyLmEsInBhY2thZ2UiKSly
+ZXR1cm4icGFja2FnZSIKcmV0dXJuIEMueEIuTmooci5hLDAscSl9LApna3U6ZnVuY3Rpb24oKXt2YXIg
+cz10aGlzLmMscj10aGlzLmIrMwpyZXR1cm4gcz5yP0MueEIuTmoodGhpcy5hLHIscy0xKToiIn0sCmdK
+ZjpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmMKcmV0dXJuIHM+MD9DLnhCLk5qKHRoaXMuYSxzLHRoaXMu
+ZCk6IiJ9LApndHA6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzCmlmKHIuZ3hBKCkpcmV0dXJuIFAuUUEo
+Qy54Qi5OaihyLmEsci5kKzEsci5lKSxudWxsKQpzPXIuYgppZihzPT09NCYmQy54Qi5uQyhyLmEsImh0
+dHAiKSlyZXR1cm4gODAKaWYocz09PTUmJkMueEIubkMoci5hLCJodHRwcyIpKXJldHVybiA0NDMKcmV0
+dXJuIDB9LApnSWk6ZnVuY3Rpb24oYSl7cmV0dXJuIEMueEIuTmoodGhpcy5hLHRoaXMuZSx0aGlzLmYp
+fSwKZ3RQOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5mLHI9dGhpcy5yCnJldHVybiBzPHI/Qy54Qi5Oaih0
+aGlzLmEscysxLHIpOiIifSwKZ0thOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5yLHI9dGhpcy5hCnJldHVy
+biBzPHIubGVuZ3RoP0MueEIueW4ocixzKzEpOiIifSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRo
+aXMuZSxwPXRoaXMuZixvPXRoaXMuYQppZihDLnhCLlFpKG8sIi8iLHEpKSsrcQppZihxPT09cClyZXR1
+cm4gQy54RApzPUguUUkoW10sdC5zKQpmb3Iocj1xO3I8cDsrK3IpaWYoQy54Qi5PKG8scik9PT00Nyl7
+Qy5ObS5pKHMsQy54Qi5OaihvLHEscikpCnE9cisxfUMuTm0uaShzLEMueEIuTmoobyxxLHApKQpyZXR1
+cm4gUC5BRihzLHQuTil9LApnaFk6ZnVuY3Rpb24oKXtpZih0aGlzLmY+PXRoaXMucilyZXR1cm4gQy5D
+TQpyZXR1cm4gbmV3IFAuR2ooUC5XWCh0aGlzLmd0UCgpKSx0LmR3KX0sCmtYOmZ1bmN0aW9uKGEpe3Zh
+ciBzPXRoaXMuZCsxCnJldHVybiBzK2EubGVuZ3RoPT09dGhpcy5lJiZDLnhCLlFpKHRoaXMuYSxhLHMp
+fSwKTjk6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5yLHE9cy5hCmlmKHI+PXEubGVuZ3RoKXJldHVy
+biBzCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKHEsMCxyKSxzLmIscy5jLHMuZCxzLmUscy5mLHIscy54
+KX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT10aGlzLGg9bnVsbAp0
+LmM5LmEoYikKcz1pLmdGaSgpCnI9cz09PSJmaWxlIgpxPWkuYwpwPXE+MD9DLnhCLk5qKGkuYSxpLmIr
+MyxxKToiIgpvPWkuZ3hBKCk/aS5ndHAoaSk6aApxPWkuYwppZihxPjApbj1DLnhCLk5qKGkuYSxxLGku
+ZCkKZWxzZSBuPXAubGVuZ3RoIT09MHx8byE9bnVsbHx8cj8iIjpoCnE9aS5hCm09Qy54Qi5OaihxLGku
+ZSxpLmYpCmlmKCFyKWw9biE9bnVsbCYmbS5sZW5ndGghPT0wCmVsc2UgbD0hMAppZihsJiYhQy54Qi5u
+QyhtLCIvIikpbT0iLyIrbQprPVAubGUoaCwwLDAsYikKbD1pLnIKaj1sPHEubGVuZ3RoP0MueEIueW4o
+cSxsKzEpOmgKcmV0dXJuIFAuQ2cocyxwLG4sbyxtLGssail9LApaSTpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy5tUyhQLmhLKGEpKX0sCm1TOmZ1bmN0aW9uKGEpe2lmKGEgaW5zdGFuY2VvZiBQLlVmKXJldHVy
+biB0aGlzLnUxKHRoaXMsYSkKcmV0dXJuIHRoaXMuUmUoKS5tUyhhKX0sCnUxOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQsYz1iLmIKaWYoYz4wKXJldHVybiBiCnM9
+Yi5jCmlmKHM+MCl7cj1hLmIKaWYocjw9MClyZXR1cm4gYgpxPXI9PT00CmlmKHEmJkMueEIubkMoYS5h
+LCJmaWxlIikpcD1iLmUhPT1iLmYKZWxzZSBpZihxJiZDLnhCLm5DKGEuYSwiaHR0cCIpKXA9IWIua1go
+IjgwIikKZWxzZSBwPSEocj09PTUmJkMueEIubkMoYS5hLCJodHRwcyIpKXx8IWIua1goIjQ0MyIpCmlm
+KHApe289cisxCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLG8pK0MueEIueW4oYi5hLGMrMSks
+cixzK28sYi5kK28sYi5lK28sYi5mK28sYi5yK28sYS54KX1lbHNlIHJldHVybiB0aGlzLlJlKCkubVMo
+Yil9bj1iLmUKYz1iLmYKaWYobj09PWMpe3M9Yi5yCmlmKGM8cyl7cj1hLmYKbz1yLWMKcmV0dXJuIG5l
+dyBQLlVmKEMueEIuTmooYS5hLDAscikrQy54Qi55bihiLmEsYyksYS5iLGEuYyxhLmQsYS5lLGMrbyxz
+K28sYS54KX1jPWIuYQppZihzPGMubGVuZ3RoKXtyPWEucgpyZXR1cm4gbmV3IFAuVWYoQy54Qi5Oaihh
+LmEsMCxyKStDLnhCLnluKGMscyksYS5iLGEuYyxhLmQsYS5lLGEuZixzKyhyLXMpLGEueCl9cmV0dXJu
+IGEuTjkoKX1zPWIuYQppZihDLnhCLlFpKHMsIi8iLG4pKXttPWEuZQpsPVAuUngodGhpcykKaz1sPjA/
+bDptCm89ay1uCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLGspK0MueEIueW4ocyxuKSxhLmIs
+YS5jLGEuZCxtLGMrbyxiLnIrbyxhLngpfWo9YS5lCmk9YS5mCmlmKGo9PT1pJiZhLmM+MCl7Zm9yKDtD
+LnhCLlFpKHMsIi4uLyIsbik7KW4rPTMKbz1qLW4rMQpyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihhLmEs
+MCxqKSsiLyIrQy54Qi55bihzLG4pLGEuYixhLmMsYS5kLGosYytvLGIucitvLGEueCl9aD1hLmEKbD1Q
+LlJ4KHRoaXMpCmlmKGw+PTApZz1sCmVsc2UgZm9yKGc9ajtDLnhCLlFpKGgsIi4uLyIsZyk7KWcrPTMK
+Zj0wCndoaWxlKCEwKXtlPW4rMwppZighKGU8PWMmJkMueEIuUWkocywiLi4vIixuKSkpYnJlYWs7Kytm
+Cm49ZX1mb3IoZD0iIjtpPmc7KXstLWkKaWYoQy54Qi5PKGgsaSk9PT00Nyl7aWYoZj09PTApe2Q9Ii8i
+CmJyZWFrfS0tZgpkPSIvIn19aWYoaT09PWcmJmEuYjw9MCYmIUMueEIuUWkoaCwiLyIsaikpe24tPWYq
+MwpkPSIifW89aS1uK2QubGVuZ3RoCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGgsMCxpKStkK0MueEIu
+eW4ocyxuKSxhLmIsYS5jLGEuZCxqLGMrbyxiLnIrbyxhLngpfSwKdDQ6ZnVuY3Rpb24oKXt2YXIgcyxy
+LHE9dGhpcyxwPXEuYgppZihwPj0wKXtzPSEocD09PTQmJkMueEIubkMocS5hLCJmaWxlIikpCnA9c31l
+bHNlIHA9ITEKaWYocCl0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJv
+bSBhICIrcS5nRmkoKSsiIFVSSSIpKQpwPXEuZgpzPXEuYQppZihwPHMubGVuZ3RoKXtpZihwPHEucil0
+aHJvdyBILmIoUC5MNCh1LmkpKQp0aHJvdyBILmIoUC5MNCh1LmwpKX1yPSQud1EoKQppZihILm9UKHIp
+KXA9UC5tbihxKQplbHNle2lmKHEuYzxxLmQpSC52KFAuTDQodS5qKSkKcD1DLnhCLk5qKHMscS5lLHAp
+fXJldHVybiBwfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMueQpyZXR1cm4gcz09bnVsbD90aGlz
+Lnk9Qy54Qi5naU8odGhpcy5hKTpzfSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJldHVybiEx
+CmlmKHRoaXM9PT1iKXJldHVybiEwCnJldHVybiB0LmRELmIoYikmJnRoaXMuYT09PWIudygwKX0sClJl
+OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPW51bGwscT1zLmdGaSgpLHA9cy5na3UoKSxvPXMuYz4wP3Mu
+Z0pmKHMpOnIsbj1zLmd4QSgpP3MuZ3RwKHMpOnIsbT1zLmEsbD1zLmYsaz1DLnhCLk5qKG0scy5lLGwp
+LGo9cy5yCmw9bDxqP3MuZ3RQKCk6cgpyZXR1cm4gUC5DZyhxLHAsbyxuLGssbCxqPG0ubGVuZ3RoP3Mu
+Z0thKCk6cil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LAokaWlEOjF9ClAucWUucHJvdG90
+eXBlPXt9ClcucUUucHJvdG90eXBlPXt9ClcuR2gucHJvdG90eXBlPXsKc0xVOmZ1bmN0aW9uKGEsYil7
+YS5ocmVmPWJ9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9LAokaUdoOjF9ClcuZlkucHJv
+dG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0KVy5yWi5wcm90b3R5cGU9eyRp
+clo6MX0KVy5Bei5wcm90b3R5cGU9eyRpQXo6MX0KVy5RUC5wcm90b3R5cGU9eyRpUVA6MX0KVy5ueC5w
+cm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLm9KLnByb3RvdHlwZT17
+CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19ClcuaWQucHJvdG90eXBlPXt9ClcuUUYucHJv
+dG90eXBlPXt9ClcuTmgucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0K
+Vy5hZS5wcm90b3R5cGU9ewpEYzpmdW5jdGlvbihhLGIpe3JldHVybiBhLmNyZWF0ZUhUTUxEb2N1bWVu
+dChiKX19ClcuSUIucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPWEubGVmdApyLnRvU3Ry
+aW5nCnI9IlJlY3RhbmdsZSAoIitILkVqKHIpKyIsICIKcz1hLnRvcApzLnRvU3RyaW5nCnM9citILkVq
+KHMpKyIpICIKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1zK0guRWoocikrIiB4ICIKcz1hLmhlaWdodApz
+LnRvU3RyaW5nCnJldHVybiByK0guRWoocyl9LApETjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoYj09
+bnVsbClyZXR1cm4hMQppZih0LnEuYihiKSl7cz1hLmxlZnQKcy50b1N0cmluZwpyPWIubGVmdApyLnRv
+U3RyaW5nCmlmKHM9PT1yKXtzPWEudG9wCnMudG9TdHJpbmcKcj1iLnRvcApyLnRvU3RyaW5nCmlmKHM9
+PT1yKXtzPWEud2lkdGgKcy50b1N0cmluZwpyPWIud2lkdGgKci50b1N0cmluZwppZihzPT09cil7cz1h
+LmhlaWdodApzLnRvU3RyaW5nCnI9Yi5oZWlnaHQKci50b1N0cmluZwpyPXM9PT1yCnM9cn1lbHNlIHM9
+ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITEKcmV0dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7
+dmFyIHMscixxLHA9YS5sZWZ0CnAudG9TdHJpbmcKcD1DLkNELmdpTyhwKQpzPWEudG9wCnMudG9TdHJp
+bmcKcz1DLkNELmdpTyhzKQpyPWEud2lkdGgKci50b1N0cmluZwpyPUMuQ0QuZ2lPKHIpCnE9YS5oZWln
+aHQKcS50b1N0cmluZwpyZXR1cm4gVy5yRShwLHMscixDLkNELmdpTyhxKSl9LAokaXRuOjF9ClcuTlEu
+cHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy53ei5wcm90b3R5cGU9
+ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXt2YXIg
+cwpILnVQKGIpCnM9dGhpcy5hCmlmKGI8MHx8Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1
+cm4gdGhpcy4kdGkuYy5hKHNbYl0pfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuJHRpLmMuYShjKQp0
+aHJvdyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSBsaXN0IikpfX0KVy5jdi5wcm90b3R5cGU9ewpnUWc6
+ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLmk3KGEpfSwKZ1A6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBX
+Lkk0KGEpfSwKc1A6ZnVuY3Rpb24oYSxiKXt2YXIgcwp0LlEuYShiKQpzPXRoaXMuZ1AoYSkKcy5WMSgw
+KQpzLkZWKDAsYil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxvY2FsTmFtZX0sCkZGOmZ1bmN0aW9u
+KGEpe3ZhciBzPSEhYS5zY3JvbGxJbnRvVmlld0lmTmVlZGVkCmlmKHMpYS5zY3JvbGxJbnRvVmlld0lm
+TmVlZGVkKCkKZWxzZSBhLnNjcm9sbEludG9WaWV3KCl9LApuejpmdW5jdGlvbihhLGIsYyxkLGUpe3Zh
+ciBzLHI9dGhpcy5yNihhLGMsZCxlKQpzd2l0Y2goYi50b0xvd2VyQ2FzZSgpKXtjYXNlImJlZm9yZWJl
+Z2luIjpzPWEucGFyZW50Tm9kZQpzLnRvU3RyaW5nCkouRWgocyxyLGEpCmJyZWFrCmNhc2UiYWZ0ZXJi
+ZWdpbiI6cz1hLmNoaWxkTm9kZXMKdGhpcy5tSyhhLHIscy5sZW5ndGg+MD9zWzBdOm51bGwpCmJyZWFr
+CmNhc2UiYmVmb3JlZW5kIjphLmFwcGVuZENoaWxkKHIpCmJyZWFrCmNhc2UiYWZ0ZXJlbmQiOnM9YS5w
+YXJlbnROb2RlCnMudG9TdHJpbmcKSi5FaChzLHIsYS5uZXh0U2libGluZykKYnJlYWsKZGVmYXVsdDpI
+LnYoUC54WSgiSW52YWxpZCBwb3NpdGlvbiAiK2IpKX19LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIg
+cyxyLHEscAppZihjPT1udWxsKXtpZihkPT1udWxsKXtzPSQubHQKaWYocz09bnVsbCl7cz1ILlFJKFtd
+LHQudikKcj1uZXcgVy52RChzKQpDLk5tLmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJsKCkpCiQu
+bHQ9cgpkPXJ9ZWxzZSBkPXN9cz0kLkVVCmlmKHM9PW51bGwpe3M9bmV3IFcuS28oZCkKJC5FVT1zCmM9
+c31lbHNle3MuYT1kCmM9c319ZWxzZSBpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJ2YWxpZGF0b3Ig
+Y2FuIG9ubHkgYmUgcGFzc2VkIGlmIHRyZWVTYW5pdGl6ZXIgaXMgbnVsbCIpKQppZigkLnhvPT1udWxs
+KXtzPWRvY3VtZW50CnI9cy5pbXBsZW1lbnRhdGlvbgpyLnRvU3RyaW5nCnI9Qy5tSC5EYyhyLCIiKQok
+LnhvPXIKJC5CTz1yLmNyZWF0ZVJhbmdlKCkKcj0kLnhvLmNyZWF0ZUVsZW1lbnQoImJhc2UiKQp0LmNS
+LmEocikKcz1zLmJhc2VVUkkKcy50b1N0cmluZwpyLmhyZWY9cwokLnhvLmhlYWQuYXBwZW5kQ2hpbGQo
+cil9cz0kLnhvCmlmKHMuYm9keT09bnVsbCl7cj1zLmNyZWF0ZUVsZW1lbnQoImJvZHkiKQpDLkJaLnNH
+UyhzLHQucC5hKHIpKX1zPSQueG8KaWYodC5wLmIoYSkpe3M9cy5ib2R5CnMudG9TdHJpbmcKcT1zfWVs
+c2V7cy50b1N0cmluZwpxPXMuY3JlYXRlRWxlbWVudChhLnRhZ05hbWUpCiQueG8uYm9keS5hcHBlbmRD
+aGlsZChxKX1pZigiY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50IiBpbiB3aW5kb3cuUmFuZ2UucHJvdG90
+eXBlJiYhQy5ObS50ZyhDLlNxLGEudGFnTmFtZSkpeyQuQk8uc2VsZWN0Tm9kZUNvbnRlbnRzKHEpCnM9
+JC5CTwpzLnRvU3RyaW5nCnA9cy5jcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQoYj09bnVsbD8ibnVsbCI6
+Yil9ZWxzZXtKLndmKHEsYikKcD0kLnhvLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpmb3IoO3M9cS5m
+aXJzdENoaWxkLHMhPW51bGw7KXAuYXBwZW5kQ2hpbGQocyl9aWYocSE9PSQueG8uYm9keSlKLkx0KHEp
+CmMuUG4ocCkKZG9jdW1lbnQuYWRvcHROb2RlKHApCnJldHVybiBwfSwKQUg6ZnVuY3Rpb24oYSxiLGMp
+e3JldHVybiB0aGlzLnI2KGEsYixjLG51bGwpfSwKc2hmOmZ1bmN0aW9uKGEsYil7dGhpcy5ZQyhhLGIp
+fSwKcGs6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuc2E0KGEsbnVsbCkKYS5hcHBlbmRDaGlsZCh0aGlzLnI2
+KGEsYixudWxsLGMpKX0sCllDOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMucGsoYSxiLG51bGwpfSwK
+c1JOOmZ1bmN0aW9uKGEsYil7YS5pbm5lckhUTUw9Yn0sCmduczpmdW5jdGlvbihhKXtyZXR1cm4gYS50
+YWdOYW1lfSwKZ1ZsOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5ldShhLCJjbGljayIsITEsdC5rKX0s
+CiRpY3Y6MX0KVy5Ddi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5oLmIodC5BLmEo
+YSkpfSwKJFM6MjV9ClcuZWEucHJvdG90eXBlPXskaWVhOjF9ClcuRDAucHJvdG90eXBlPXsKT246ZnVu
+Y3Rpb24oYSxiLGMsZCl7dC5idy5hKGMpCmlmKGMhPW51bGwpdGhpcy52KGEsYixjLGQpfSwKQjpmdW5j
+dGlvbihhLGIsYyl7cmV0dXJuIHRoaXMuT24oYSxiLGMsbnVsbCl9LAp2OmZ1bmN0aW9uKGEsYixjLGQp
+e3JldHVybiBhLmFkZEV2ZW50TGlzdGVuZXIoYixILnRSKHQuYncuYShjKSwxKSxkKX0sCiRpRDA6MX0K
+Vy5oSC5wcm90b3R5cGU9eyRpaEg6MX0KVy5oNC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1
+cm4gYS5sZW5ndGh9fQpXLmJyLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0
+aH19ClcuVmIucHJvdG90eXBlPXsKc0dTOmZ1bmN0aW9uKGEsYil7YS5ib2R5PWJ9fQpXLmZKLnByb3Rv
+dHlwZT17CmVvOmZ1bmN0aW9uKGEsYixjLGQpe3JldHVybiBhLm9wZW4oYixjLCEwKX0sCiRpZko6MX0K
+Vy53YS5wcm90b3R5cGU9e30KVy5TZy5wcm90b3R5cGU9eyRpU2c6MX0KVy53Ny5wcm90b3R5cGU9ewpn
+RHI6ZnVuY3Rpb24oYSl7aWYoIm9yaWdpbiIgaW4gYSlyZXR1cm4gYS5vcmlnaW4KcmV0dXJuIEguRWoo
+YS5wcm90b2NvbCkrIi8vIitILkVqKGEuaG9zdCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmco
+YSl9LAokaXc3OjF9ClcuQWoucHJvdG90eXBlPXskaUFqOjF9ClcuZTcucHJvdG90eXBlPXsKZ3I4OmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuYSxyPXMuY2hpbGROb2Rlcy5sZW5ndGgKaWYocj09PTApdGhyb3cg
+SC5iKFAuUFYoIk5vIGVsZW1lbnRzIikpCmlmKHI+MSl0aHJvdyBILmIoUC5QVigiTW9yZSB0aGFuIG9u
+ZSBlbGVtZW50IikpCnM9cy5maXJzdENoaWxkCnMudG9TdHJpbmcKcmV0dXJuIHN9LApGVjpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG8KdC5laC5hKGIpCmlmKGIgaW5zdGFuY2VvZiBXLmU3KXtzPWIuYQpy
+PXRoaXMuYQppZihzIT09cilmb3IocT1zLmNoaWxkTm9kZXMubGVuZ3RoLHA9MDtwPHE7KytwKXtvPXMu
+Zmlyc3RDaGlsZApvLnRvU3RyaW5nCnIuYXBwZW5kQ2hpbGQobyl9cmV0dXJufWZvcihzPWIuZ20oYiks
+cj10aGlzLmE7cy5GKCk7KXIuYXBwZW5kQ2hpbGQocy5nbCgpKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcyxyCnQuQS5hKGMpCnM9dGhpcy5hCnI9cy5jaGlsZE5vZGVzCmlmKGI8MHx8Yj49ci5sZW5ndGgp
+cmV0dXJuIEguT0gocixiKQpzLnJlcGxhY2VDaGlsZChjLHJbYl0pfSwKZ206ZnVuY3Rpb24oYSl7dmFy
+IHM9dGhpcy5hLmNoaWxkTm9kZXMKcmV0dXJuIG5ldyBXLlc5KHMscy5sZW5ndGgsSC56SyhzKS5DKCJX
+OTxHbS5FPiIpKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2hpbGROb2Rlcy5sZW5ndGh9
+LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC51UChiKQpzPXRoaXMuYS5jaGlsZE5vZGVzCmlmKGI8MHx8
+Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1cm4gc1tiXX19ClcudUgucHJvdG90eXBlPXsK
+d2c6ZnVuY3Rpb24oYSl7dmFyIHM9YS5wYXJlbnROb2RlCmlmKHMhPW51bGwpcy5yZW1vdmVDaGlsZChh
+KX0sCkQ0OmZ1bmN0aW9uKGEpe3ZhciBzCmZvcig7cz1hLmZpcnN0Q2hpbGQscyE9bnVsbDspYS5yZW1v
+dmVDaGlsZChzKX0sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9YS5ub2RlVmFsdWUKcmV0dXJuIHM9PW51bGw/
+dGhpcy5VKGEpOnN9LApzYTQ6ZnVuY3Rpb24oYSxiKXthLnRleHRDb250ZW50PWJ9LAptSzpmdW5jdGlv
+bihhLGIsYyl7cmV0dXJuIGEuaW5zZXJ0QmVmb3JlKGIsYyl9LAokaXVIOjF9ClcuQkgucHJvdG90eXBl
+PXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikK
+aWYoYj4+PjAhPT1ifHxiPj1hLmxlbmd0aCl0aHJvdyBILmIoUC5DZihiLGEsbnVsbCxudWxsLG51bGwp
+KQpyZXR1cm4gYVtiXX0sClk1OmZ1bmN0aW9uKGEsYixjKXt0LkEuYShjKQp0aHJvdyBILmIoUC5MNCgi
+Q2Fubm90IGFzc2lnbiBlbGVtZW50IG9mIGltbXV0YWJsZSBMaXN0LiIpKX0sCmd0SDpmdW5jdGlvbihh
+KXtpZihhLmxlbmd0aD4wKXJldHVybiBhWzBdCnRocm93IEguYihQLlBWKCJObyBlbGVtZW50cyIpKX0s
+CkU6ZnVuY3Rpb24oYSxiKXtpZihiPDB8fGI+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsYikKcmV0dXJu
+IGFbYl19LAokaWJROjEsCiRpWGo6MSwKJGljWDoxLAokaXpNOjF9ClcuU04ucHJvdG90eXBlPXt9Clcu
+ZXcucHJvdG90eXBlPXskaWV3OjF9ClcubHAucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJu
+IGEubGVuZ3RofX0KVy5UYi5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyCmlm
+KCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5wcm90b3R5cGUpcmV0dXJu
+IHRoaXMuRFcoYSxiLGMsZCkKcz1XLlU5KCI8dGFibGU+IitILkVqKGIpKyI8L3RhYmxlPiIsYyxkKQpy
+PWRvY3VtZW50LmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpyLnRvU3RyaW5nCnMudG9TdHJpbmcKbmV3
+IFcuZTcocikuRlYoMCxuZXcgVy5lNyhzKSkKcmV0dXJuIHJ9fQpXLkl2LnByb3RvdHlwZT17CnI2OmZ1
+bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwCmlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGlu
+IHdpbmRvdy5SYW5nZS5wcm90b3R5cGUpcmV0dXJuIHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApy
+PXMuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnM9Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxl
+IiksYixjLGQpCnMudG9TdHJpbmcKcz1uZXcgVy5lNyhzKQpxPXMuZ3I4KHMpCnEudG9TdHJpbmcKcz1u
+ZXcgVy5lNyhxKQpwPXMuZ3I4KHMpCnIudG9TdHJpbmcKcC50b1N0cmluZwpuZXcgVy5lNyhyKS5GVigw
+LG5ldyBXLmU3KHApKQpyZXR1cm4gcn19ClcuV1AucHJvdG90eXBlPXsKcjY6ZnVuY3Rpb24oYSxiLGMs
+ZCl7dmFyIHMscixxCmlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5w
+cm90b3R5cGUpcmV0dXJuIHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApyPXMuY3JlYXRlRG9jdW1l
+bnRGcmFnbWVudCgpCnM9Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxlIiksYixjLGQpCnMudG9T
+dHJpbmcKcz1uZXcgVy5lNyhzKQpxPXMuZ3I4KHMpCnIudG9TdHJpbmcKcS50b1N0cmluZwpuZXcgVy5l
+NyhyKS5GVigwLG5ldyBXLmU3KHEpKQpyZXR1cm4gcn19ClcueVkucHJvdG90eXBlPXsKcGs6ZnVuY3Rp
+b24oYSxiLGMpe3ZhciBzLHIKdGhpcy5zYTQoYSxudWxsKQpzPWEuY29udGVudApzLnRvU3RyaW5nCkou
+YlQocykKcj10aGlzLnI2KGEsYixudWxsLGMpCmEuY29udGVudC5hcHBlbmRDaGlsZChyKX0sCllDOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMucGsoYSxiLG51bGwpfSwKJGl5WToxfQpXLnc2LnByb3RvdHlw
+ZT17fQpXLks1LnByb3RvdHlwZT17ClBvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1XLlAxKGEub3Blbihi
+LGMpKQpyZXR1cm4gc30sCmdtVzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sb2NhdGlvbn0sCnVzOmZ1bmN0
+aW9uKGEsYil7cmV0dXJuIGEuY29uZmlybShiKX0sCiRpSzU6MSwKJGl2NjoxfQpXLkNtLnByb3RvdHlw
+ZT17JGlDbToxfQpXLkNRLnByb3RvdHlwZT17JGlDUToxfQpXLnc0LnByb3RvdHlwZT17Cnc6ZnVuY3Rp
+b24oYSl7dmFyIHMscj1hLmxlZnQKci50b1N0cmluZwpyPSJSZWN0YW5nbGUgKCIrSC5FaihyKSsiLCAi
+CnM9YS50b3AKcy50b1N0cmluZwpzPXIrSC5FaihzKSsiKSAiCnI9YS53aWR0aApyLnRvU3RyaW5nCnI9
+cytILkVqKHIpKyIgeCAiCnM9YS5oZWlnaHQKcy50b1N0cmluZwpyZXR1cm4gcitILkVqKHMpfSwKRE46
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGI9PW51bGwpcmV0dXJuITEKaWYodC5xLmIoYikpe3M9YS5s
+ZWZ0CnMudG9TdHJpbmcKcj1iLmxlZnQKci50b1N0cmluZwppZihzPT09cil7cz1hLnRvcApzLnRvU3Ry
+aW5nCnI9Yi50b3AKci50b1N0cmluZwppZihzPT09cil7cz1hLndpZHRoCnMudG9TdHJpbmcKcj1iLndp
+ZHRoCnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS5oZWlnaHQKcy50b1N0cmluZwpyPWIuaGVpZ2h0CnIu
+dG9TdHJpbmcKcj1zPT09cgpzPXJ9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSEx
+CnJldHVybiBzfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEubGVmdApwLnRvU3RyaW5nCnA9
+Qy5DRC5naU8ocCkKcz1hLnRvcApzLnRvU3RyaW5nCnM9Qy5DRC5naU8ocykKcj1hLndpZHRoCnIudG9T
+dHJpbmcKcj1DLkNELmdpTyhyKQpxPWEuaGVpZ2h0CnEudG9TdHJpbmcKcmV0dXJuIFcuckUocCxzLHIs
+Qy5DRC5naU8ocSkpfX0KVy5yaC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5n
+dGh9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQppZihiPj4+MCE9PWJ8fGI+PWEubGVuZ3RoKXRocm93
+IEguYihQLkNmKGIsYSxudWxsLG51bGwsbnVsbCkpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxi
+LGMpe3QuQS5hKGMpCnRocm93IEguYihQLkw0KCJDYW5ub3QgYXNzaWduIGVsZW1lbnQgb2YgaW1tdXRh
+YmxlIExpc3QuIikpfSwKRTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5ndGgpcmV0dXJuIEgu
+T0goYSxiKQpyZXR1cm4gYVtiXX0sCiRpYlE6MSwKJGlYajoxLAokaWNYOjEsCiRpek06MX0KVy5jZi5w
+cm90b3R5cGU9ewpLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbwp0LmVBLmEoYikKZm9yKHM9dGhp
+cy5ndmMoKSxyPXMubGVuZ3RoLHE9dGhpcy5hLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAs
+SC5saykocyksKytwKXtvPXNbcF0KYi4kMihvLHEuZ2V0QXR0cmlidXRlKG8pKX19LApndmM6ZnVuY3Rp
+b24oKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLmEuYXR0cmlidXRlcwptLnRvU3RyaW5nCnM9SC5RSShb
+XSx0LnMpCmZvcihyPW0ubGVuZ3RoLHE9dC5oOSxwPTA7cDxyOysrcCl7aWYocD49bS5sZW5ndGgpcmV0
+dXJuIEguT0gobSxwKQpvPXEuYShtW3BdKQppZihvLm5hbWVzcGFjZVVSST09bnVsbCl7bj1vLm5hbWUK
+bi50b1N0cmluZwpDLk5tLmkocyxuKX19cmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
+aXMuZ3ZjKCkubGVuZ3RoPT09MH19ClcuaTcucHJvdG90eXBlPXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9
+SC5vVCh0aGlzLmEuaGFzQXR0cmlidXRlKGEpKQpyZXR1cm4gc30sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1
+cm4gdGhpcy5hLmdldEF0dHJpYnV0ZShILmgoYikpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuYS5z
+ZXRBdHRyaWJ1dGUoYixjKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH19
+ClcuU3kucHJvdG90eXBlPXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vVCh0aGlzLmEuYS5oYXNBdHRy
+aWJ1dGUoImRhdGEtIit0aGlzLk9VKGEpKSkKcmV0dXJuIHN9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJu
+IHRoaXMuYS5hLmdldEF0dHJpYnV0ZSgiZGF0YS0iK3RoaXMuT1UoSC5oKGIpKSl9LApZNTpmdW5jdGlv
+bihhLGIsYyl7dGhpcy5hLmEuc2V0QXR0cmlidXRlKCJkYXRhLSIrdGhpcy5PVShiKSxjKX0sCks6ZnVu
+Y3Rpb24oYSxiKXt0aGlzLmEuSygwLG5ldyBXLktTKHRoaXMsdC5lQS5hKGIpKSl9LApndmM6ZnVuY3Rp
+b24oKXt2YXIgcz1ILlFJKFtdLHQucykKdGhpcy5hLksoMCxuZXcgVy5BMyh0aGlzLHMpKQpyZXR1cm4g
+c30sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH0sCmdsMDpmdW5jdGlvbihh
+KXtyZXR1cm4gdGhpcy5ndmMoKS5sZW5ndGg9PT0wfSwKbjpmdW5jdGlvbihhKXt2YXIgcyxyLHE9SC5R
+SShhLnNwbGl0KCItIiksdC5zKQpmb3Iocz0xO3M8cS5sZW5ndGg7KytzKXtyPXFbc10KaWYoci5sZW5n
+dGg+MClDLk5tLlk1KHEscyxyWzBdLnRvVXBwZXJDYXNlKCkrSi5LVihyLDEpKX1yZXR1cm4gQy5ObS5r
+KHEsIiIpfSwKT1U6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbwpmb3Iocz1hLmxlbmd0aCxyPTAscT0i
+IjtyPHM7KytyKXtwPWFbcl0Kbz1wLnRvTG93ZXJDYXNlKCkKcT0ocCE9PW8mJnI+MD9xKyItIjpxKStv
+fXJldHVybiBxLmNoYXJDb2RlQXQoMCk9PTA/cTpxfX0KVy5LUy5wcm90b3R5cGU9ewokMjpmdW5jdGlv
+bihhLGIpe2lmKEouYXUoYSwiZGF0YS0iKSl0aGlzLmIuJDIodGhpcy5hLm4oQy54Qi55bihhLDUpKSxi
+KX0sCiRTOjE1fQpXLkEzLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7aWYoSi5hdShhLCJkYXRh
+LSIpKUMuTm0uaSh0aGlzLmIsdGhpcy5hLm4oQy54Qi55bihhLDUpKSl9LAokUzoxNX0KVy5JNC5wcm90
+b3R5cGU9ewpEOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz1QLkxzKHQuTikKZm9yKHM9dGhpcy5hLmNs
+YXNzTmFtZS5zcGxpdCgiICIpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Epe3A9Si5UMChzW3FdKQppZihw
+Lmxlbmd0aCE9PTApby5pKDAscCl9cmV0dXJuIG99LApYOmZ1bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05h
+bWU9dC5DLmEoYSkuaygwLCIgIil9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmNsYXNzTGlz
+dC5sZW5ndGh9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3RoPT09
+MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmNsYXNzTGlzdC5sZW5ndGghPT0wfSwKVjE6
+ZnVuY3Rpb24oYSl7dGhpcy5hLmNsYXNzTmFtZT0iIn0sCnRnOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhp
+cy5hLmNsYXNzTGlzdC5jb250YWlucyhiKQpyZXR1cm4gc30sCmk6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
+CkguaChiKQpzPXRoaXMuYS5jbGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMuYWRkKGIpCnJldHVybiFy
+fSwKUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQppZih0eXBlb2YgYj09InN0cmluZyIpe3M9dGhpcy5h
+LmNsYXNzTGlzdApyPXMuY29udGFpbnMoYikKcy5yZW1vdmUoYikKcT1yfWVsc2UgcT0hMQpyZXR1cm4g
+cX0sCkZWOmZ1bmN0aW9uKGEsYil7Vy5UTih0aGlzLmEsdC5RLmEoYikpfX0KVy5Gay5wcm90b3R5cGU9
+e30KVy5STy5wcm90b3R5cGU9e30KVy5ldS5wcm90b3R5cGU9e30KVy54Qy5wcm90b3R5cGU9e30KVy52
+Ti5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLiQxKHQuQi5hKGEpKX0sCiRT
+OjI3fQpXLkpRLnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEpe3ZhciBzCmlmKCQub3IuYT09PTApe2Zv
+cihzPTA7czwyNjI7KytzKSQub3IuWTUoMCxDLmNtW3NdLFcucFMoKSkKZm9yKHM9MDtzPDEyOysrcykk
+Lm9yLlk1KDAsQy5CSVtzXSxXLlY0KCkpfX0sCmkwOmZ1bmN0aW9uKGEpe3JldHVybiAkLkFOKCkudGco
+MCxXLnJTKGEpKX0sCkViOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz0kLm9yLnEoMCxILkVqKFcuclMoYSkp
+KyI6OiIrYikKaWYocz09bnVsbClzPSQub3IucSgwLCIqOjoiK2IpCmlmKHM9PW51bGwpcmV0dXJuITEK
+cmV0dXJuIEgueTgocy4kNChhLGIsYyx0aGlzKSl9LAokaWtGOjF9ClcuR20ucHJvdG90eXBlPXsKZ206
+ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLlc5KGEsdGhpcy5nQShhKSxILnpLKGEpLkMoIlc5PEdtLkU+
+IikpfX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1cm4gQy5ObS5Wcih0aGlzLmEs
+bmV3IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBDLk5tLlZyKHRoaXMuYSxuZXcg
+Vy5FZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVy
+biB0LkUuYShhKS5pMCh0aGlzLmEpfSwKJFM6MTZ9ClcuRWcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
+YSl7cmV0dXJuIHQuRS5hKGEpLkViKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjE2fQpXLm02LnBy
+b3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQp0aGlzLmEuRlYoMCxjKQpzPWIu
+ZXYoMCxuZXcgVy5FbygpKQpyPWIuZXYoMCxuZXcgVy5XaygpKQp0aGlzLmIuRlYoMCxzKQpxPXRoaXMu
+YwpxLkZWKDAsQy54RCkKcS5GVigwLHIpfSwKaTA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS50Zygw
+LFcuclMoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMscj1XLnJTKGEpLHE9cy5jCmlm
+KHEudGcoMCxILkVqKHIpKyI6OiIrYikpcmV0dXJuIHMuZC5EdChjKQplbHNlIGlmKHEudGcoMCwiKjo6
+IitiKSlyZXR1cm4gcy5kLkR0KGMpCmVsc2V7cT1zLmIKaWYocS50ZygwLEguRWoocikrIjo6IitiKSly
+ZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCxILkVq
+KHIpKyI6OioiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6KiIpKXJldHVybiEwfXJldHVybiEx
+fSwKJGlrRjoxfQpXLkVvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiFDLk5tLnRnKEMu
+QkksSC5oKGEpKX0sCiRTOjd9ClcuV2sucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEMu
+Tm0udGcoQy5CSSxILmgoYSkpfSwKJFM6N30KVy5jdC5wcm90b3R5cGU9ewpFYjpmdW5jdGlvbihhLGIs
+Yyl7aWYodGhpcy5qRihhLGIsYykpcmV0dXJuITAKaWYoYj09PSJ0ZW1wbGF0ZSImJmM9PT0iIilyZXR1
+cm4hMAppZihhLmdldEF0dHJpYnV0ZSgidGVtcGxhdGUiKT09PSIiKXJldHVybiB0aGlzLmUudGcoMCxi
+KQpyZXR1cm4hMX19ClcuSUEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIlRFTVBMQVRF
+OjoiK0guRWooSC5oKGEpKX0sCiRTOjV9ClcuT3cucHJvdG90eXBlPXsKaTA6ZnVuY3Rpb24oYSl7dmFy
+IHMKaWYodC5ldy5iKGEpKXJldHVybiExCnM9dC5nNy5iKGEpCmlmKHMmJlcuclMoYSk9PT0iZm9yZWln
+bk9iamVjdCIpcmV0dXJuITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0sCkViOmZ1bmN0aW9uKGEsYixj
+KXtpZihiPT09ImlzInx8Qy54Qi5uQyhiLCJvbiIpKXJldHVybiExCnJldHVybiB0aGlzLmkwKGEpfSwK
+JGlrRjoxfQpXLlc5LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5jKzEscT1z
+LmIKaWYocjxxKXtzLnNwKEoueDkocy5hLHIpKQpzLmM9cgpyZXR1cm4hMH1zLnNwKG51bGwpCnMuYz1x
+CnJldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKc3A6ZnVuY3Rpb24oYSl7dGhp
+cy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KVy5kVy5wcm90b3R5cGU9eyRpRDA6MSwk
+aXY2OjF9ClcubWsucHJvdG90eXBlPXskaXkwOjF9ClcuS28ucHJvdG90eXBlPXsKUG46ZnVuY3Rpb24o
+YSl7dmFyIHMscj1uZXcgVy5mbSh0aGlzKQpkb3tzPXRoaXMuYgpyLiQyKGEsbnVsbCl9d2hpbGUocyE9
+PXRoaXMuYil9LApFUDpmdW5jdGlvbihhLGIpeysrdGhpcy5iCmlmKGI9PW51bGx8fGIhPT1hLnBhcmVu
+dE5vZGUpSi5MdChhKQplbHNlIGIucmVtb3ZlQ2hpbGQoYSl9LApJNDpmdW5jdGlvbihhLGIpe3ZhciBz
+LHIscSxwLG8sbj0hMCxtPW51bGwsbD1udWxsCnRyeXttPUouaWcoYSkKbD1tLmEuZ2V0QXR0cmlidXRl
+KCJpcyIpCnQuaC5hKGEpCnM9ZnVuY3Rpb24oYyl7aWYoIShjLmF0dHJpYnV0ZXMgaW5zdGFuY2VvZiBO
+YW1lZE5vZGVNYXApKXJldHVybiB0cnVlCmlmKGMuaWQ9PSJsYXN0Q2hpbGQifHxjLm5hbWU9PSJsYXN0
+Q2hpbGQifHxjLmlkPT0icHJldmlvdXNTaWJsaW5nInx8Yy5uYW1lPT0icHJldmlvdXNTaWJsaW5nInx8
+Yy5pZD09ImNoaWxkcmVuInx8Yy5uYW1lPT0iY2hpbGRyZW4iKXJldHVybiB0cnVlCnZhciBrPWMuY2hp
+bGROb2RlcwppZihjLmxhc3RDaGlsZCYmYy5sYXN0Q2hpbGQhPT1rW2subGVuZ3RoLTFdKXJldHVybiB0
+cnVlCmlmKGMuY2hpbGRyZW4paWYoIShjLmNoaWxkcmVuIGluc3RhbmNlb2YgSFRNTENvbGxlY3Rpb258
+fGMuY2hpbGRyZW4gaW5zdGFuY2VvZiBOb2RlTGlzdCkpcmV0dXJuIHRydWUKdmFyIGo9MAppZihjLmNo
+aWxkcmVuKWo9Yy5jaGlsZHJlbi5sZW5ndGgKZm9yKHZhciBpPTA7aTxqO2krKyl7dmFyIGg9Yy5jaGls
+ZHJlbltpXQppZihoLmlkPT0iYXR0cmlidXRlcyJ8fGgubmFtZT09ImF0dHJpYnV0ZXMifHxoLmlkPT0i
+bGFzdENoaWxkInx8aC5uYW1lPT0ibGFzdENoaWxkInx8aC5pZD09InByZXZpb3VzU2libGluZyJ8fGgu
+bmFtZT09InByZXZpb3VzU2libGluZyJ8fGguaWQ9PSJjaGlsZHJlbiJ8fGgubmFtZT09ImNoaWxkcmVu
+IilyZXR1cm4gdHJ1ZX1yZXR1cm4gZmFsc2V9KGEpCm49SC5vVChzKT8hMDohKGEuYXR0cmlidXRlcyBp
+bnN0YW5jZW9mIE5hbWVkTm9kZU1hcCl9Y2F0Y2gocCl7SC5SdShwKX1yPSJlbGVtZW50IHVucHJpbnRh
+YmxlIgp0cnl7cj1KLncoYSl9Y2F0Y2gocCl7SC5SdShwKX10cnl7cT1XLnJTKGEpCnRoaXMua1IodC5o
+LmEoYSksYixuLHIscSx0LmYuYShtKSxILmsobCkpfWNhdGNoKHApe2lmKEguUnUocCkgaW5zdGFuY2Vv
+ZiBQLmMpdGhyb3cgcAplbHNle3RoaXMuRVAoYSxiKQp3aW5kb3cKbz0iUmVtb3ZpbmcgY29ycnVwdGVk
+IGVsZW1lbnQgIitILkVqKHIpCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29u
+c29sZS53YXJuKG8pfX19LAprUjpmdW5jdGlvbihhLGIsYyxkLGUsZixnKXt2YXIgcyxyLHEscCxvLG4s
+bT10aGlzCmlmKGMpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZWxlbWVudCBkdWUgdG8gY29y
+cnVwdGVkIGF0dHJpYnV0ZXMgb24gPCIrZCsiPiIKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQi
+KXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0dXJufWlmKCFtLmEuaTAoYSkpe20uRVAoYSxiKQp3aW5k
+b3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBlbGVtZW50IDwiK0guRWooZSkrIj4gZnJvbSAiK0guRWoo
+YikKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0
+dXJufWlmKGchPW51bGwpaWYoIW0uYS5FYihhLCJpcyIsZykpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVt
+b3ZpbmcgZGlzYWxsb3dlZCB0eXBlIGV4dGVuc2lvbiA8IitILkVqKGUpKycgaXM9IicrZysnIj4nCmlm
+KHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKHMpCnJldHVybn1z
+PWYuZ3ZjKCkKcj1ILlFJKHMuc2xpY2UoMCksSC50NihzKSkKZm9yKHE9Zi5ndmMoKS5sZW5ndGgtMSxz
+PWYuYTtxPj0wOy0tcSl7aWYocT49ci5sZW5ndGgpcmV0dXJuIEguT0gocixxKQpwPXJbcV0Kbz1tLmEK
+bj1KLmNIKHApCkguaChwKQppZighby5FYihhLG4scy5nZXRBdHRyaWJ1dGUocCkpKXt3aW5kb3cKbz0i
+UmVtb3ZpbmcgZGlzYWxsb3dlZCBhdHRyaWJ1dGUgPCIrSC5FaihlKSsiICIrcCsnPSInK0guRWoocy5n
+ZXRBdHRyaWJ1dGUocCkpKyciPicKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5j
+b25zb2xlLndhcm4obykKcy5yZW1vdmVBdHRyaWJ1dGUocCl9fWlmKHQuYVcuYihhKSl7cz1hLmNvbnRl
+bnQKcy50b1N0cmluZwptLlBuKHMpfX0sCiRpb246MX0KVy5mbS5wcm90b3R5cGU9ewokMjpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMuYQpzd2l0Y2goYS5ub2RlVHlwZSl7Y2FzZSAxOm0u
+STQoYSxiKQpicmVhawpjYXNlIDg6Y2FzZSAxMTpjYXNlIDM6Y2FzZSA0OmJyZWFrCmRlZmF1bHQ6bS5F
+UChhLGIpfXM9YS5sYXN0Q2hpbGQKZm9yKHE9dC5BO3MhPW51bGw7KXtyPW51bGwKdHJ5e3I9cy5wcmV2
+aW91c1NpYmxpbmcKaWYociE9bnVsbCl7cD1yLm5leHRTaWJsaW5nCm89cwpvPXA9PW51bGw/byE9bnVs
+bDpwIT09bwpwPW99ZWxzZSBwPSExCmlmKHApe3A9UC5QVigiQ29ycnVwdCBIVE1MIikKdGhyb3cgSC5i
+KHApfX1jYXRjaChuKXtILlJ1KG4pCnA9cS5hKHMpOysrbS5iCm89cC5wYXJlbnROb2RlCm89YT09bnVs
+bD9vIT1udWxsOmEhPT1vCmlmKG8pe289cC5wYXJlbnROb2RlCmlmKG8hPW51bGwpby5yZW1vdmVDaGls
+ZChwKX1lbHNlIGEucmVtb3ZlQ2hpbGQocCkKcz1udWxsCnI9YS5sYXN0Q2hpbGR9aWYocyE9bnVsbCl0
+aGlzLiQyKHMsYSkKcz1yfX0sCiRTOjMwfQpXLkxlLnByb3RvdHlwZT17fQpXLks3LnByb3RvdHlwZT17
+fQpXLnJCLnByb3RvdHlwZT17fQpXLlhXLnByb3RvdHlwZT17fQpXLm9hLnByb3RvdHlwZT17fQpQLmlK
+LnByb3RvdHlwZT17ClZIOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5hLHE9ci5sZW5ndGgKZm9yKHM9
+MDtzPHE7KytzKWlmKHJbc109PT1hKXJldHVybiBzCkMuTm0uaShyLGEpCkMuTm0uaSh0aGlzLmIsbnVs
+bCkKcmV0dXJuIHF9LApQdjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD10aGlzLG89e30KaWYoYT09bnVs
+bClyZXR1cm4gYQppZihILnJRKGEpKXJldHVybiBhCmlmKHR5cGVvZiBhPT0ibnVtYmVyIilyZXR1cm4g
+YQppZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIGEKaWYoYSBpbnN0YW5jZW9mIFAuaVApcmV0dXJu
+IG5ldyBEYXRlKGEuYSkKaWYodC5mdi5iKGEpKXRocm93IEguYihQLlNZKCJzdHJ1Y3R1cmVkIGNsb25l
+IG9mIFJlZ0V4cCIpKQppZih0LmM4LmIoYSkpcmV0dXJuIGEKaWYodC53LmIoYSkpcmV0dXJuIGEKaWYo
+dC5JLmIoYSkpcmV0dXJuIGEKcz10LmRFLmIoYSl8fCExCmlmKHMpcmV0dXJuIGEKaWYodC5mLmIoYSkp
+e3I9cC5WSChhKQpzPXAuYgppZihyPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLHIpCnE9by5hPXNbcl0K
+aWYocSE9bnVsbClyZXR1cm4gcQpxPXt9Cm8uYT1xCkMuTm0uWTUocyxyLHEpCmEuSygwLG5ldyBQLkUy
+KG8scCkpCnJldHVybiBvLmF9aWYodC5qLmIoYSkpe3I9cC5WSChhKQpvPXAuYgppZihyPj1vLmxlbmd0
+aClyZXR1cm4gSC5PSChvLHIpCnE9b1tyXQppZihxIT1udWxsKXJldHVybiBxCnJldHVybiBwLmVrKGEs
+cil9aWYodC5lSC5iKGEpKXtyPXAuVkgoYSkKcz1wLmIKaWYocj49cy5sZW5ndGgpcmV0dXJuIEguT0go
+cyxyKQpxPW8uYj1zW3JdCmlmKHEhPW51bGwpcmV0dXJuIHEKcT17fQpvLmI9cQpDLk5tLlk1KHMscixx
+KQpwLmltKGEsbmV3IFAuamcobyxwKSkKcmV0dXJuIG8uYn10aHJvdyBILmIoUC5TWSgic3RydWN0dXJl
+ZCBjbG9uZSBvZiBvdGhlciB0eXBlIikpfSwKZWs6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPUouVTYoYSks
+cT1yLmdBKGEpLHA9bmV3IEFycmF5KHEpCkMuTm0uWTUodGhpcy5iLGIscCkKZm9yKHM9MDtzPHE7Kytz
+KUMuTm0uWTUocCxzLHRoaXMuUHYoci5xKGEscykpKQpyZXR1cm4gcH19ClAuRTIucHJvdG90eXBlPXsK
+JDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuYVthXT10aGlzLmIuUHYoYil9LAokUzozMX0KUC5qZy5wcm90
+b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS5iW2FdPXRoaXMuYi5QdihiKX0sCiRTOjE3fQpQ
+LkJmLnByb3RvdHlwZT17CmltOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5iOC5hKGIpCmZvcihz
+PU9iamVjdC5rZXlzKGEpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Epe3A9c1txXQpiLiQyKHAsYVtwXSl9
+fX0KUC5Bcy5wcm90b3R5cGU9ewpWOmZ1bmN0aW9uKGEpe3ZhciBzCkguaChhKQpzPSQuaEcoKS5iCmlm
+KHR5cGVvZiBhIT0ic3RyaW5nIilILnYoSC50TChhKSkKaWYocy50ZXN0KGEpKXJldHVybiBhCnRocm93
+IEguYihQLkwzKGEsInZhbHVlIiwiTm90IGEgdmFsaWQgY2xhc3MgdG9rZW4iKSl9LAp3OmZ1bmN0aW9u
+KGEpe3JldHVybiB0aGlzLkQoKS5rKDAsIiAiKX0sCmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuRCgp
+CnJldHVybiBQLnJqKHMscy5yLEguTGgocykuYyl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
+RCgpLmE9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hIT09MH0sCmdBOmZ1bmN0
+aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hfSwKdGc6ZnVuY3Rpb24oYSxiKXt0aGlzLlYoYikKcmV0dXJu
+IHRoaXMuRCgpLnRnKDAsYil9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC5oKGIpCnRoaXMuVihiKQpz
+PXRoaXMuT1MobmV3IFAuR0UoYikpCnJldHVybiBILnk4KHM9PW51bGw/ITE6cyl9LApSOmZ1bmN0aW9u
+KGEsYil7dmFyIHMscgppZih0eXBlb2YgYiE9InN0cmluZyIpcmV0dXJuITEKdGhpcy5WKGIpCnM9dGhp
+cy5EKCkKcj1zLlIoMCxiKQp0aGlzLlgocykKcmV0dXJuIHJ9LApGVjpmdW5jdGlvbihhLGIpe3RoaXMu
+T1MobmV3IFAuTjcodGhpcyx0LlEuYShiKSkpfSwKZVI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLkQo
+KQpyZXR1cm4gSC5iSyhzLGIsSC5MaChzKS5DKCJsZi5FIikpfSwKRTpmdW5jdGlvbihhLGIpe3JldHVy
+biB0aGlzLkQoKS5FKDAsYil9LApWMTpmdW5jdGlvbihhKXt0aGlzLk9TKG5ldyBQLnVRKCkpfSwKT1M6
+ZnVuY3Rpb24oYSl7dmFyIHMscgp0LmJVLmEoYSkKcz10aGlzLkQoKQpyPWEuJDEocykKdGhpcy5YKHMp
+CnJldHVybiByfX0KUC5HRS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5DLmEoYSku
+aSgwLHRoaXMuYSl9LAokUzozM30KUC5ONy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcz10
+aGlzLmIscj1ILnQ2KHMpCnJldHVybiB0LkMuYShhKS5GVigwLG5ldyBILmxKKHMsci5DKCJxVSgxKSIp
+LmEodGhpcy5hLmd1TSgpKSxyLkMoImxKPDEscVU+IikpKX0sCiRTOjE4fQpQLnVRLnByb3RvdHlwZT17
+CiQxOmZ1bmN0aW9uKGEpe3QuQy5hKGEpCmlmKGEuYT4wKXthLmI9YS5jPWEuZD1hLmU9YS5mPW51bGwK
+YS5hPTAKYS5TKCl9cmV0dXJuIG51bGx9LAokUzoxOH0KUC5oRi5wcm90b3R5cGU9eyRpaEY6MX0KUC5Q
+Qy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0LlkuYShhKQpzPWZ1bmN0aW9uKGIsYyxk
+KXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4gYihjLGQsdGhpcyxBcnJheS5wcm90b3R5cGUuc2xpY2Uu
+YXBwbHkoYXJndW1lbnRzKSl9fShQLlI0LGEsITEpClAuRG0ocywkLnooKSxhKQpyZXR1cm4gc30sCiRT
+OjR9ClAubXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyB0aGlzLmEoYSl9LAok
+Uzo0fQpQLlFTLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5yNyhhKX0sCiRT
+OjM1fQpQLm5wLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5UeihhLHQuYW0p
+fSwKJFM6NDZ9ClAuVXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLkU0KGEp
+fSwKJFM6Mzd9ClAuRTQucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe2lmKHR5cGVvZiBiIT0ic3Ry
+aW5nIiYmdHlwZW9mIGIhPSJudW1iZXIiKXRocm93IEguYihQLnhZKCJwcm9wZXJ0eSBpcyBub3QgYSBT
+dHJpbmcgb3IgbnVtIikpCnJldHVybiBQLmRVKHRoaXMuYVtiXSl9LApZNTpmdW5jdGlvbihhLGIsYyl7
+aWYodHlwZW9mIGIhPSJzdHJpbmciJiZ0eXBlb2YgYiE9Im51bWJlciIpdGhyb3cgSC5iKFAueFkoInBy
+b3BlcnR5IGlzIG5vdCBhIFN0cmluZyBvciBudW0iKSkKdGhpcy5hW2JdPVAud1koYyl9LApETjpmdW5j
+dGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKcmV0dXJuIGIgaW5zdGFuY2VvZiBQLkU0JiZ0aGlz
+LmE9PT1iLmF9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIKdHJ5e3M9U3RyaW5nKHRoaXMuYSkKcmV0dXJu
+IHN9Y2F0Y2gocil7SC5SdShyKQpzPXRoaXMueGIoMCkKcmV0dXJuIHN9fSwKVjc6ZnVuY3Rpb24oYSxi
+KXt2YXIgcyxyPXRoaXMuYQppZihiPT1udWxsKXM9bnVsbAplbHNle3M9SC50NihiKQpzPVAuQ0gobmV3
+IEgubEooYixzLkMoIkAoMSkiKS5hKFAuaUcoKSkscy5DKCJsSjwxLEA+IikpLCEwLHQueil9cmV0dXJu
+IFAuZFUoclthXS5hcHBseShyLHMpKX0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gMH19ClAucjcucHJv
+dG90eXBlPXt9ClAuVHoucHJvdG90eXBlPXsKY1A6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPWE8MHx8
+YT49cy5nQShzKQppZihyKXRocm93IEguYihQLlRFKGEsMCxzLmdBKHMpLG51bGwsbnVsbCkpfSwKcTpm
+dW5jdGlvbihhLGIpe2lmKEgub2soYikpdGhpcy5jUChiKQpyZXR1cm4gdGhpcy4kdGkuYy5hKHRoaXMu
+VXIoMCxiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5jUChiKQp0aGlzLmJoKDAsYixjKX0sCmdB
+OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5sZW5ndGgKaWYodHlwZW9mIHM9PT0ibnVtYmVyIiYmcz4+
+PjA9PT1zKXJldHVybiBzCnRocm93IEguYihQLlBWKCJCYWQgSnNBcnJheSBsZW5ndGgiKSl9LAokaWJR
+OjEsCiRpY1g6MSwKJGl6TToxfQpQLnZnLnByb3RvdHlwZT17Clk1OmZ1bmN0aW9uKGEsYixjKXtyZXR1
+cm4gdGhpcy5lNCgwLGIsYyl9fQpQLm5kLnByb3RvdHlwZT17JGluZDoxfQpQLktlLnByb3RvdHlwZT17
+CkQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMuYS5nZXRBdHRyaWJ1dGUoImNsYXNzIiksbj1Q
+LkxzKHQuTikKaWYobz09bnVsbClyZXR1cm4gbgpmb3Iocz1vLnNwbGl0KCIgIikscj1zLmxlbmd0aCxx
+PTA7cTxyOysrcSl7cD1KLlQwKHNbcV0pCmlmKHAubGVuZ3RoIT09MCluLmkoMCxwKX1yZXR1cm4gbn0s
+Clg6ZnVuY3Rpb24oYSl7dGhpcy5hLnNldEF0dHJpYnV0ZSgiY2xhc3MiLGEuaygwLCIgIikpfX0KUC5o
+aS5wcm90b3R5cGU9ewpnUDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuS2UoYSl9LApzaGY6ZnVuY3Rp
+b24oYSxiKXt0aGlzLllDKGEsYil9LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4K
+aWYoZD09bnVsbCl7cz1ILlFJKFtdLHQudikKZD1uZXcgVy52RChzKQpDLk5tLmkocyxXLlR3KG51bGwp
+KQpDLk5tLmkocyxXLkJsKCkpCkMuTm0uaShzLG5ldyBXLk93KCkpfWM9bmV3IFcuS28oZCkKcj0nPHN2
+ZyB2ZXJzaW9uPSIxLjEiPicrSC5FaihiKSsiPC9zdmc+IgpzPWRvY3VtZW50CnE9cy5ib2R5CnEudG9T
+dHJpbmcKcD1DLlJZLkFIKHEscixjKQpvPXMuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnAudG9TdHJp
+bmcKcz1uZXcgVy5lNyhwKQpuPXMuZ3I4KHMpCmZvcig7cz1uLmZpcnN0Q2hpbGQscyE9bnVsbDspby5h
+cHBlbmRDaGlsZChzKQpyZXR1cm4gb30sCm56OmZ1bmN0aW9uKGEsYixjLGQsZSl7dGhyb3cgSC5iKFAu
+TDQoIkNhbm5vdCBpbnZva2UgaW5zZXJ0QWRqYWNlbnRIdG1sIG9uIFNWRy4iKSl9LApnVmw6ZnVuY3Rp
+b24oYSl7cmV0dXJuIG5ldyBXLmV1KGEsImNsaWNrIiwhMSx0LmspfSwKJGloaToxfQpVLmQyLnByb3Rv
+dHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzLG49dC5YLG09dC5fLGw9UC5GbChu
+LG0pLGs9by5hCmlmKGshPW51bGwpe3M9SC5RSShbXSx0LkcpCmZvcihyPWsubGVuZ3RoLHE9MDtxPGsu
+bGVuZ3RoO2subGVuZ3RoPT09cnx8KDAsSC5saykoayksKytxKXtwPWtbcV0Kcy5wdXNoKFAuRUYoWyJk
+ZXNjcmlwdGlvbiIscC5hLCJocmVmIixwLmJdLG4sbSkpfWwuWTUoMCwiZWRpdHMiLHMpfWwuWTUoMCwi
+ZXhwbGFuYXRpb24iLG8uYikKbC5ZNSgwLCJsaW5lIixvLmMpCmwuWTUoMCwiZGlzcGxheVBhdGgiLG8u
+ZCkKbC5ZNSgwLCJ1cmlQYXRoIixvLmUpCm49by5mCmlmKG4hPW51bGwpe209SC5RSShbXSx0LkcpCmZv
+cihrPW4ubGVuZ3RoLHE9MDtxPG4ubGVuZ3RoO24ubGVuZ3RoPT09a3x8KDAsSC5saykobiksKytxKW0u
+cHVzaChuW3FdLkx0KCkpCmwuWTUoMCwidHJhY2VzIixtKX1yZXR1cm4gbH19ClUuU2UucHJvdG90eXBl
+PXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbImRlc2NyaXB0aW9uIix0aGlzLmEsImhyZWYiLHRo
+aXMuYl0sdC5YLHQuXyl9fQpVLk1sLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJuIFAuRUYo
+WyJocmVmIix0aGlzLmEsImxpbmUiLHRoaXMuYiwicGF0aCIsdGhpcy5jXSx0LlgsdC5fKX19ClUueUQu
+cHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD1ILlFJKFtdLHQuRykKZm9yKHM9dGhp
+cy5iLHI9cy5sZW5ndGgscT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Ep
+cC5wdXNoKHNbcV0uTHQoKSkKcmV0dXJuIFAuRUYoWyJkZXNjcmlwdGlvbiIsdGhpcy5hLCJlbnRyaWVz
+IixwXSx0LlgsdC5fKX19ClUud2IucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD10
+aGlzLG89UC5GbCh0LlgsdC5fKQpvLlk1KDAsImRlc2NyaXB0aW9uIixwLmEpCnM9cC5iCmlmKHMhPW51
+bGwpby5ZNSgwLCJmdW5jdGlvbiIscykKcz1wLmMKaWYocyE9bnVsbClvLlk1KDAsImxpbmsiLHMuTHQo
+KSkKcz1wLmQKaWYocy5sZW5ndGghPT0wKXtyPUgudDYocykKcT1yLkMoImxKPDEsWjA8cVUqLE1oKj4q
+PiIpCm8uWTUoMCwiaGludEFjdGlvbnMiLFAuWTEobmV3IEgubEoocyxyLkMoIlowPHFVKixNaCo+Kigx
+KSIpLmEobmV3IFUuYjAoKSkscSksITAscS5DKCJhTC5FIikpKX1yZXR1cm4gb319ClUuYU4ucHJvdG90
+eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIFIubnoodC50LmEoYSkpfSwKJFM6Mzh9ClUuYjAucHJv
+dG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuYVguYShhKS5MdCgpfSwKJFM6Mzl9CkIuajgu
+cHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbImxpbmUiLHRoaXMuYSwiZXhwbGFu
+YXRpb24iLHRoaXMuYiwib2Zmc2V0Iix0aGlzLmNdLHQuWCx0Ll8pfX0KQi5xcC5wcm90b3R5cGU9ewpM
+dDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcyxrPXQuWCxqPVAuRmwoayx0LmRwKQpm
+b3Iocz1sLmQscz1zLmdQdShzKSxzPXMuZ20ocykscj10Ll8scT10Lkc7cy5GKCk7KXtwPXMuZ2woKQpv
+PXAuYQpuPUguUUkoW10scSkKZm9yKHA9Si5JVChwLmIpO3AuRigpOyl7bT1wLmdsKCkKbi5wdXNoKFAu
+RUYoWyJsaW5lIixtLmEsImV4cGxhbmF0aW9uIixtLmIsIm9mZnNldCIsbS5jXSxrLHIpKX1qLlk1KDAs
+byxuKX1yZXR1cm4gUC5FRihbInJlZ2lvbnMiLGwuYSwibmF2aWdhdGlvbkNvbnRlbnQiLGwuYiwic291
+cmNlQ29kZSIsbC5jLCJlZGl0cyIsal0sayxyKX19ClQubVEucHJvdG90eXBlPXt9CkwuZS5wcm90b3R5
+cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbQp0LmFMLmEoYSkKcz13aW5kb3cubG9j
+YXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlvbi5ocmVmKQpxPUwuYUsod2luZG93Lmxv
+Y2F0aW9uLmhyZWYpCkwuR2UoKQppZihzIT09Ii8iJiZzIT09Si5UMChkb2N1bWVudC5xdWVyeVNlbGVj
+dG9yKCIucm9vdCIpLnRleHRDb250ZW50KSlMLkc3KHMscixxLCEwLG5ldyBMLlZXKHMscixxKSkKcD1k
+b2N1bWVudApvPUoucUYocC5xdWVyeVNlbGVjdG9yKCIuYXBwbHktbWlncmF0aW9uIikpCm49by4kdGkK
+bT1uLkMoIn4oMSk/IikuYShuZXcgTC5vWigpKQp0LlouYShudWxsKQpXLkpFKG8uYSxvLmIsbSwhMSxu
+LmMpCm49Si5xRihwLnF1ZXJ5U2VsZWN0b3IoIi5yZXJ1bi1taWdyYXRpb24iKSkKbT1uLiR0aQpXLkpF
+KG4uYSxuLmIsbS5DKCJ+KDEpPyIpLmEobmV3IEwuSGkoKSksITEsbS5jKQptPUoucUYocC5xdWVyeVNl
+bGVjdG9yKCIucmVwb3J0LXByb2JsZW0iKSkKbj1tLiR0aQpXLkpFKG0uYSxtLmIsbi5DKCJ+KDEpPyIp
+LmEobmV3IEwuQlQoKSksITEsbi5jKQpwPUoucUYocC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSAu
+Y2xvc2UiKSkKbj1wLiR0aQpXLkpFKHAuYSxwLmIsbi5DKCJ+KDEpPyIpLmEobmV3IEwuUFkoKSksITEs
+bi5jKQpuPUoucUYoJC5jMCgpKQpwPW4uJHRpClcuSkUobi5hLG4uYixwLkMoIn4oMSk/IikuYShuZXcg
+TC51OCgpKSwhMSxwLmMpfSwKJFM6MTl9CkwuVlcucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZy
+KHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjJ9Ckwub1oucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
+YSl7dmFyIHMscixxLHAsbwp0Lk8uYShhKQppZihILm9UKEMub2wudXMod2luZG93LCJUaGlzIHdpbGwg
+YXBwbHkgdGhlIGNoYW5nZXMgeW91J3ZlIHByZXZpZXdlZCB0byB5b3VyIHdvcmtpbmcgZGlyZWN0b3J5
+LiBJdCBpcyByZWNvbW1lbmRlZCB5b3UgY29tbWl0IGFueSBjaGFuZ2VzIHlvdSBtYWRlIGJlZm9yZSBk
+b2luZyB0aGlzLiIpKSl7cz1ILlFJKFtdLHQuRykKZm9yKHI9JC5JUixxPXIubGVuZ3RoLHA9MDtwPHIu
+bGVuZ3RoO3IubGVuZ3RoPT09cXx8KDAsSC5saykociksKytwKXMucHVzaChyW3BdLkx0KCkpCnM9TC50
+eSgiL2FwcGx5LW1pZ3JhdGlvbiIsUC5FRihbIm5hdmlnYXRpb25UcmVlIixzXSx0LlgsdC5kcCkpLlc3
+KG5ldyBMLmpyKCksdC5QKQpvPW5ldyBMLnFsKCkKdC5iNy5hKG51bGwpCnI9cy4kdGkKcT0kLlgzCmlm
+KHEhPT1DLk5VKW89UC5WSChvLHEpCnMueGYobmV3IFAuRmUobmV3IFAudnMocSxyKSwyLG51bGwsbyxy
+LkMoIkA8MT4iKS5LcShyLmMpLkMoIkZlPDEsMj4iKSkpfX0sCiRTOjF9CkwuanIucHJvdG90eXBlPXsK
+JDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC50LmEoYSkKcz1kb2N1bWVudC5ib2R5CnMuY2xhc3NMaXN0LnJl
+bW92ZSgicHJvcG9zZWQiKQpzLmNsYXNzTGlzdC5hZGQoImFwcGxpZWQiKX0sCiRTOjQyfQpMLnFsLnBy
+b3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7TC5DMigiQ291bGRuJ3QgYXBwbHkgbWlncmF0aW9uIixh
+LGIpfSwKJEM6IiQyIiwKJFI6MiwKJFM6MTd9CkwuSGkucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7
+cmV0dXJuIHRoaXMueG4odC5PLmEoYSkpfSwKeG46ZnVuY3Rpb24oYSl7dmFyIHM9MCxyPVAuRlgodC5Q
+KSxxPTEscCxvPVtdLG4sbSxsLGssagp2YXIgJGFzeW5jJCQxPVAubHooZnVuY3Rpb24oYixjKXtpZihi
+PT09MSl7cD1jCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6cT0zCmRvY3VtZW50LmJvZHku
+Y2xhc3NMaXN0LmFkZCgicmVydW5uaW5nIikKcz02CnJldHVybiBQLmpRKEwudHkoIi9yZXJ1bi1taWdy
+YXRpb24iLG51bGwpLCRhc3luYyQkMSkKY2FzZSA2Om49YwppZihILm9UKEgueTgoSi54OShuLCJzdWNj
+ZXNzIikpKSl3aW5kb3cubG9jYXRpb24ucmVsb2FkKCkKZWxzZSBMLkswKHQuZUUuYShKLng5KG4sImVy
+cm9ycyIpKSkKby5wdXNoKDUpCnM9NApicmVhawpjYXNlIDM6cT0yCmo9cAptPUguUnUoaikKbD1ILnRz
+KGopCkwuQzIoIkZhaWxlZCB0byByZXJ1biBtaWdyYXRpb24iLG0sbCkKby5wdXNoKDUpCnM9NApicmVh
+awpjYXNlIDI6bz1bMV0KY2FzZSA0OnE9MQpkb2N1bWVudC5ib2R5LmNsYXNzTGlzdC5yZW1vdmUoInJl
+cnVubmluZyIpCnM9by5wb3AoKQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNlIDE6
+cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkJDEscil9LAokUzoyMH0KTC5CVC5w
+cm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0Lk8uYShhKQpDLm9sLlBvKHdpbmRvdyxQLlhkKCJodHRw
+cyIsImdpdGh1Yi5jb20iLCJkYXJ0LWxhbmcvc2RrL2lzc3Vlcy9uZXciLFAuRUYoWyJ0aXRsZSIsIkN1
+c3RvbWVyLXJlcG9ydGVkIGlzc3VlIHdpdGggTk5CRCBtaWdyYXRpb24gdG9vbCIsImxhYmVscyIsdS5k
+LCJib2R5IiwiIyMjIyBTdGVwcyB0byByZXByb2R1Y2VcblxuIyMjIyBXaGF0IGRpZCB5b3UgZXhwZWN0
+IHRvIGhhcHBlbj9cblxuIyMjIyBXaGF0IGFjdHVhbGx5IGhhcHBlbmVkP1xuXG5fU2NyZWVuc2hvdHMg
+YXJlIGFwcHJlY2lhdGVkX1xuXG4qKkRhcnQgU0RLIHZlcnNpb24qKjogIitILkVqKGRvY3VtZW50Lmdl
+dEVsZW1lbnRCeUlkKCJzZGstdmVyc2lvbiIpLnRleHRDb250ZW50KSsiXG5cblRoYW5rcyBmb3IgZmls
+aW5nIVxuIl0sdC5YLHQueikpLmduRCgpLCJyZXBvcnQtcHJvYmxlbSIpfSwKJFM6MX0KTC5QWS5wcm90
+b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPWRvY3VtZW50LnF1ZXJ5U2VsZWN0
+b3IoIi5wb3B1cC1wYW5lIikuc3R5bGUKcy5kaXNwbGF5PSJub25lIgpyZXR1cm4ibm9uZSJ9LAokUzo0
+NH0KTC51OC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscAp0Lk8uYShhKQpzPSQu
+RDkoKS5pbm5lclRleHQKcj10LmcuYShkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCcubmF2LXBhbmVsIFtk
+YXRhLW5hbWUqPSInK0guRWooVy5MaihzKSkrJyJdJykucGFyZW50Tm9kZSkKcT1yLnF1ZXJ5U2VsZWN0
+b3IoIi5zdGF0dXMtaWNvbiIpCnA9TC55dygkLklSLHMpCmlmKHAgaW5zdGFuY2VvZiBMLmNEJiZILm9U
+KHAueCkpe0wuT3QocCkKTC54bihxLHApCkwuQVIocixwKX19LAokUzoxfQpMLkwucHJvdG90eXBlPXsK
+JDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuYUwuYShhKQpzPXdpbmRvdy5sb2NhdGlvbi5wYXRobmFt
+ZQpyPUwuRzYod2luZG93LmxvY2F0aW9uLmhyZWYpCnE9TC5hSyh3aW5kb3cubG9jYXRpb24uaHJlZikK
+aWYocy5sZW5ndGg+MSlMLkc3KHMscixxLCExLG51bGwpCmVsc2V7TC5CRShzLEIud1IoKSwhMCkKTC5C
+WCgiJm5ic3A7IixudWxsKX19LAokUzoxOX0KTC5XeC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2
+YXIgcyxyLHEscCxvPSJjb2xsYXBzZWQiCnQuTy5hKGEpCnM9dGhpcy5hCnI9Si5ZRShzKQpxPXRoaXMu
+YgpwPUouWUUocSkKaWYoIXIuZ1AocykudGcoMCxvKSl7ci5nUChzKS5pKDAsbykKcC5nUChxKS5pKDAs
+byl9ZWxzZXtyLmdQKHMpLlIoMCxvKQpwLmdQKHEpLlIoMCxvKX19LAokUzoxfQpMLkFPLnByb3RvdHlw
+ZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPUoucUYodC5nLmEoYSkpLHI9cy4kdGkscT1yLkMoIn4oMSk/
+IikuYShuZXcgTC5kTih0aGlzLmEpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIscSwhMSxyLmMpfSwK
+JFM6M30KTC5kTi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gTC50Mih0Lk8uYShhKSx0
+aGlzLmEpfSwKJFM6Nn0KTC5Iby5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEKdC5n
+LmEoYSkKcz1KLnFGKGEpCnI9cy4kdGkKcT1yLkMoIn4oMSk/IikuYShuZXcgTC54eihhLHRoaXMuYSkp
+CnQuWi5hKG51bGwpClcuSkUocy5hLHMuYixxLCExLHIuYyl9LAokUzozfQpMLnh6LnByb3RvdHlwZT17
+CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQuTy5hKGEpCnM9dGhpcy5hCkwuaFgodGhpcy5iLFAuUUEocy5n
+ZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhzKSkuT1UoIm9mZnNldCIpKSxudWxs
+KSxQLlFBKHMuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcocykpLk9VKCJsaW5l
+IikpLG51bGwpKX0sCiRTOjF9CkwuSUMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHM9Si5x
+Rih0LmcuYShhKSkscj1zLiR0aQpyLkMoIn4oMSk/IikuYShMLmlTKCkpCnQuWi5hKG51bGwpClcuSkUo
+cy5hLHMuYixMLmlTKCksITEsci5jKX0sCiRTOjN9CkwuZkMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
+YSl7dC5lUS5hKGEpCnRoaXMuYS5hTSgwLHRoaXMuYil9LAokUzo0N30KTC5UbS5wcm90b3R5cGU9ewok
+MTpmdW5jdGlvbihhKXtILmgoYSkKcmV0dXJuIGEubGVuZ3RoPjQwP0oubGQoYSwwLDQwKSsiLi4uIjph
+fSwKJFM6NDh9CkwublQucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0aGlzLmIs
+dGhpcy5jKX0sCiRTOjJ9CkwuTlkucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSxu
+dWxsLG51bGwpfSwKJFM6Mn0KTC51ZS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0LmF3LmEoYSkK
+cmV0dXJuIEguRWooYS5xKDAsInNldmVyaXR5IikpKyIgLSAiK0guRWooYS5xKDAsIm1lc3NhZ2UiKSkr
+IiBhdCAiK0guRWooYS5xKDAsImxvY2F0aW9uIikpKyIgLSAoIitILkVqKGEucSgwLCJjb2RlIikpKyIp
+In0sCiRTOjQ5fQpMLmVYLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuZy5hKGEpCiQuekIoKS50
+b1N0cmluZwp0LmRILmEoJC5vdygpLnEoMCwiaGxqcyIpKS5WNygiaGlnaGxpZ2h0QmxvY2siLFthXSl9
+LAokUzozfQpMLkVFLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdC5PLmEoYSkucHJl
+dmVudERlZmF1bHQoKQpzPXRoaXMuYQpyPXRoaXMuYgpMLmFmKHdpbmRvdy5sb2NhdGlvbi5wYXRobmFt
+ZSxzLHIsITAsbmV3IEwuUUwocyxyKSkKTC5oWCh0aGlzLmMscyxyKX0sCiRTOjF9CkwuUUwucHJvdG90
+eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHdpbmRvdy5sb2NhdGlvbi5wYXRobmFtZSx0aGlzLmEsdGhp
+cy5iKX0sCiRTOjJ9CkwuVlMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscj0ic2VsZWN0
+ZWQtZmlsZSIKdC5nLmEoYSkKYS50b1N0cmluZwpzPUouWUUoYSkKaWYoYS5nZXRBdHRyaWJ1dGUoImRh
+dGEtIituZXcgVy5TeShuZXcgVy5pNyhhKSkuT1UoIm5hbWUiKSk9PT10aGlzLmEuYSlzLmdQKGEpLmko
+MCxyKQplbHNlIHMuZ1AoYSkuUigwLHIpfSwKJFM6M30KTC5URC5wcm90b3R5cGU9ewokMTpmdW5jdGlv
+bihhKXt2YXIgcyxyCnQuTy5hKGEpCnM9dGhpcy5hCnN3aXRjaChzLmdMKCkpe2Nhc2UgQy5jdzpicmVh
+awpjYXNlIEMuV0Q6cy5uRygpCmJyZWFrCmNhc2UgQy5YajpzLmMyKCkKYnJlYWsKY2FzZSBDLmRjOnMu
+YzIoKQpicmVha31yPXRoaXMuYgpMLmJMKHIscykKTC54bih0aGlzLmMscykKTC5BUihyLHMpfSwKJFM6
+MX0KTC5JZi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPXRoaXMuYQpM
+Lk90KHMpCkwueG4odGhpcy5iLHMpCkwuQVIodGhpcy5jLHMpfSwKJFM6MX0KTC50Qi5wcm90b3R5cGU9
+ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gTC50Mih0Lk8uYShhKSwhMCl9LAokUzo2fQpMLm0yLnByb3Rv
+dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlJJKHQuTy5hKGEpKX0sClJJOmZ1bmN0aW9u
+KGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuPXRoaXMsbSxsLGssaixpLGgsZyxmCnZh
+ciAkYXN5bmMkJDE9UC5seihmdW5jdGlvbihiLGMpe2lmKGI9PT0xKXtwPWMKcz1xfXdoaWxlKHRydWUp
+c3dpdGNoKHMpe2Nhc2UgMDpxPTMKaT1kb2N1bWVudAptPUMuQ0QuelEoaS5xdWVyeVNlbGVjdG9yKCIu
+Y29udGVudCIpLnNjcm9sbFRvcCkKaD10LlgKcz02CnJldHVybiBQLmpRKEwudHkoTC5RNCgiL2FwcGx5
+LWhpbnQiLFAuRmwoaCxoKSksbi5hLkx0KCkpLCRhc3luYyQkMSkKY2FzZSA2Omg9bi5iCmw9TC5Vcyho
+LmEpCnM9NwpyZXR1cm4gUC5qUShMLkc3KGwsbnVsbCxoLmIsITEsbnVsbCksJGFzeW5jJCQxKQpjYXNl
+IDc6aS5ib2R5LmNsYXNzTGlzdC5hZGQoIm5lZWRzLXJlcnVuIikKaT1pLnF1ZXJ5U2VsZWN0b3IoIi5j
+b250ZW50IikKaS50b1N0cmluZwppLnNjcm9sbFRvcD1KLlZ1KG0pCnE9MQpzPTUKYnJlYWsKY2FzZSAz
+OnE9MgpmPXAKaz1ILlJ1KGYpCmo9SC50cyhmKQpMLkMyKCJjb3VsZG4ndCBhcHBseSBoaW50IixrLGop
+CnM9NQpicmVhawpjYXNlIDI6cz0xCmJyZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIpCmNhc2Ug
+MTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyQkMSxyKX0sCiRTOjIwfQpMLlFX
+LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYSsiOlxuIit0aGlzLmJ9LAokaVJ6
+OjF9CkwuWEEucHJvdG90eXBlPXsKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiEwfSwKaTA6ZnVuY3Rp
+b24oYSl7cmV0dXJuITB9LAokaWtGOjF9CkwudnQucHJvdG90eXBlPXsKZ0w6ZnVuY3Rpb24oKXt2YXIg
+cyxyLHEscCxvLG4sbSxsPXRoaXMuZAppZihsLmxlbmd0aD09PTApcmV0dXJuIEMuY3cKcz1DLk5tLmd0
+SChsKS5nTCgpCmZvcihyPWwubGVuZ3RoLHE9ITAscD0hMCxvPTA7bzxsLmxlbmd0aDtsLmxlbmd0aD09
+PXJ8fCgwLEgubGspKGwpLCsrbyl7bj1sW29dLmdMKCkKaWYobiE9cylzPW51bGwKbT1uIT09Qy5jdwpp
+ZihtJiZuIT09Qy5XRClxPSExCmlmKG0mJm4hPT1DLlhqKXA9ITF9aWYocyE9bnVsbClyZXR1cm4gcwpp
+ZihxKXJldHVybiBDLldECmlmKHApcmV0dXJuIEMuWGoKcmV0dXJuIEMuZGN9LApMVjpmdW5jdGlvbigp
+e3ZhciBzLHIscT10aGlzLmQKaWYocSE9bnVsbClmb3Iocz1xLmxlbmd0aCxyPTA7cjxzOysrcilxW3Jd
+LmI9dGhpc30sCmMyOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAKZm9yKHM9dGhpcy5kLHI9cy5sZW5ndGgs
+cT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Epe3A9c1txXQppZihwIGlu
+c3RhbmNlb2YgTC52dClwLmMyKCkKZWxzZSBpZihwIGluc3RhbmNlb2YgTC5jRCYmSC5vVChwLngpJiZw
+LnI9PT1DLlhqKXAucj1DLldEfX0sCm5HOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAKZm9yKHM9dGhpcy5k
+LHI9cy5sZW5ndGgscT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Epe3A9
+c1txXQppZihwIGluc3RhbmNlb2YgTC52dClwLm5HKCkKZWxzZSBpZihwIGluc3RhbmNlb2YgTC5jRCYm
+SC5vVChwLngpJiZwLnI9PT1DLldEKXAucj1DLlhqfX0sCkx0OmZ1bmN0aW9uKCl7dmFyIHMscj1QLkZs
+KHQuWCx0Ll8pCnIuWTUoMCwidHlwZSIsImRpcmVjdG9yeSIpCnIuWTUoMCwibmFtZSIsdGhpcy5hKQpy
+Llk1KDAsInN1YnRyZWUiLEwuVkQodGhpcy5kKSkKcz10aGlzLmMKaWYocyE9bnVsbClyLlk1KDAsInBh
+dGgiLHMpCnJldHVybiByfX0KTC5jRC5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3ZhciBzLHI9dGhp
+cyxxPVAuRmwodC5YLHQuXykKcS5ZNSgwLCJ0eXBlIiwiZmlsZSIpCnEuWTUoMCwibmFtZSIsci5hKQpz
+PXIuYwppZihzIT1udWxsKXEuWTUoMCwicGF0aCIscykKcz1yLmQKaWYocyE9bnVsbClxLlk1KDAsImhy
+ZWYiLHMpCnM9ci5lCmlmKHMhPW51bGwpcS5ZNSgwLCJlZGl0Q291bnQiLHMpCnM9ci5mCmlmKHMhPW51
+bGwpcS5ZNSgwLCJ3YXNFeHBsaWNpdGx5T3B0ZWRPdXQiLHMpCnM9ci5yCmlmKHMhPW51bGwpcS5ZNSgw
+LCJtaWdyYXRpb25TdGF0dXMiLHMuYSkKcz1yLngKaWYocyE9bnVsbClxLlk1KDAsIm1pZ3JhdGlvblN0
+YXR1c0NhbkJlQ2hhbmdlZCIscykKcmV0dXJuIHF9LApnTDpmdW5jdGlvbigpe3JldHVybiB0aGlzLnJ9
+fQpMLkQ4LnByb3RvdHlwZT17fQpMLk85LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
+aXMuYn19CkwuR2IucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ifX0KUi5MTC5w
+cm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3JldHVybiBQLkVGKFsibm9kZUlkIix0aGlzLmIsImtpbmQi
+LHRoaXMuYS5hXSx0LlgsdC5fKX19ClIuTUQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJu
+IHQuZkUuYShhKS5hPT09dGhpcy5hLnEoMCwia2luZCIpfSwKJFM6NTB9ClIuSDcucHJvdG90eXBlPXsK
+dzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ifX0KTS5sSS5wcm90b3R5cGU9ewpXTzpmdW5jdGlvbihh
+LGIpe3ZhciBzLHIscT10LmQ0Ck0uWUYoImFic29sdXRlIixILlFJKFtiLG51bGwsbnVsbCxudWxsLG51
+bGwsbnVsbCxudWxsXSxxKSkKcz10aGlzLmEKcz1zLllyKGIpPjAmJiFzLmhLKGIpCmlmKHMpcmV0dXJu
+IGIKcz1ELmFiKCkKcj1ILlFJKFtzLGIsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLG51bGxdLHEpCk0u
+WUYoImpvaW4iLHIpCnJldHVybiB0aGlzLklQKG5ldyBILnU2KHIsdC5lSikpfSwKemY6ZnVuY3Rpb24o
+YSl7dmFyIHMscixxPVguQ0woYSx0aGlzLmEpCnEuSXgoKQpzPXEuZApyPXMubGVuZ3RoCmlmKHI9PT0w
+KXtzPXEuYgpyZXR1cm4gcz09bnVsbD8iLiI6c31pZihyPT09MSl7cz1xLmIKcmV0dXJuIHM9PW51bGw/
+Ii4iOnN9aWYoMD49cilyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnM9cS5lCmlmKDA+PXMubGVuZ3Ro
+KXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcS5JeCgpCnJldHVybiBxLncoMCl9LApJUDpmdW5jdGlv
+bihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssagp0LlEuYShhKQpmb3Iocz1hLiR0aSxyPXMuQygiYTIo
+Y1guRSkiKS5hKG5ldyBNLnE3KCkpLHE9YS5nbShhKSxzPW5ldyBILlNPKHEscixzLkMoIlNPPGNYLkU+
+IikpLHI9dGhpcy5hLHA9ITEsbz0hMSxuPSIiO3MuRigpOyl7bT1xLmdsKCkKaWYoci5oSyhtKSYmbyl7
+bD1YLkNMKG0scikKaz1uLmNoYXJDb2RlQXQoMCk9PTA/bjpuCm49Qy54Qi5OaihrLDAsci5TcChrLCEw
+KSkKbC5iPW4KaWYoci5kcyhuKSlDLk5tLlk1KGwuZSwwLHIuZ21JKCkpCm49bC53KDApfWVsc2UgaWYo
+ci5ZcihtKT4wKXtvPSFyLmhLKG0pCm49SC5FaihtKX1lbHNle2o9bS5sZW5ndGgKaWYoaiE9PTApe2lm
+KDA+PWopcmV0dXJuIEguT0gobSwwKQpqPXIuVWQobVswXSl9ZWxzZSBqPSExCmlmKCFqKWlmKHApbis9
+ci5nbUkoKQpuKz1tfXA9ci5kcyhtKX1yZXR1cm4gbi5jaGFyQ29kZUF0KDApPT0wP246bn0sCm81OmZ1
+bmN0aW9uKGEpe3ZhciBzCmlmKCF0aGlzLnkzKGEpKXJldHVybiBhCnM9WC5DTChhLHRoaXMuYSkKcy5y
+UigpCnJldHVybiBzLncoMCl9LAp5MzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssagph
+LnRvU3RyaW5nCnM9dGhpcy5hCnI9cy5ZcihhKQppZihyIT09MCl7aWYocz09PSQuS2soKSlmb3IocT0w
+O3E8cjsrK3EpaWYoQy54Qi5XKGEscSk9PT00NylyZXR1cm4hMApwPXIKbz00N31lbHNle3A9MApvPW51
+bGx9Zm9yKG49bmV3IEgucWooYSkuYSxtPW4ubGVuZ3RoLHE9cCxsPW51bGw7cTxtOysrcSxsPW8sbz1r
+KXtrPUMueEIuTyhuLHEpCmlmKHMucjQoaykpe2lmKHM9PT0kLktrKCkmJms9PT00NylyZXR1cm4hMApp
+ZihvIT1udWxsJiZzLnI0KG8pKXJldHVybiEwCmlmKG89PT00NilqPWw9PW51bGx8fGw9PT00Nnx8cy5y
+NChsKQplbHNlIGo9ITEKaWYoailyZXR1cm4hMH19aWYobz09bnVsbClyZXR1cm4hMAppZihzLnI0KG8p
+KXJldHVybiEwCmlmKG89PT00NilzPWw9PW51bGx8fHMucjQobCl8fGw9PT00NgplbHNlIHM9ITEKaWYo
+cylyZXR1cm4hMApyZXR1cm4hMX0sCkhQOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbD10
+aGlzLGs9J1VuYWJsZSB0byBmaW5kIGEgcGF0aCB0byAiJwpiPWwuV08oMCxiKQpzPWwuYQppZihzLlly
+KGIpPD0wJiZzLllyKGEpPjApcmV0dXJuIGwubzUoYSkKaWYocy5ZcihhKTw9MHx8cy5oSyhhKSlhPWwu
+V08oMCxhKQppZihzLllyKGEpPD0wJiZzLllyKGIpPjApdGhyb3cgSC5iKFguSTcoaytILkVqKGEpKyci
+IGZyb20gIicrSC5FaihiKSsnIi4nKSkKcj1YLkNMKGIscykKci5yUigpCnE9WC5DTChhLHMpCnEuclIo
+KQpwPXIuZApvPXAubGVuZ3RoCmlmKG8hPT0wKXtpZigwPj1vKXJldHVybiBILk9IKHAsMCkKcD1KLlJN
+KHBbMF0sIi4iKX1lbHNlIHA9ITEKaWYocClyZXR1cm4gcS53KDApCnA9ci5iCm89cS5iCmlmKHAhPW8p
+cD1wPT1udWxsfHxvPT1udWxsfHwhcy5OYyhwLG8pCmVsc2UgcD0hMQppZihwKXJldHVybiBxLncoMCkK
+d2hpbGUoITApe3A9ci5kCm89cC5sZW5ndGgKaWYobyE9PTApe249cS5kCm09bi5sZW5ndGgKaWYobSE9
+PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPXBbMF0KaWYoMD49bSlyZXR1cm4gSC5PSChuLDAp
+Cm49cy5OYyhwLG5bMF0pCnA9bn1lbHNlIHA9ITF9ZWxzZSBwPSExCmlmKCFwKWJyZWFrCkMuTm0uVzQo
+ci5kLDApCkMuTm0uVzQoci5lLDEpCkMuTm0uVzQocS5kLDApCkMuTm0uVzQocS5lLDEpfXA9ci5kCm89
+cC5sZW5ndGgKaWYobyE9PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPUouUk0ocFswXSwiLi4i
+KX1lbHNlIHA9ITEKaWYocCl0aHJvdyBILmIoWC5JNyhrK0guRWooYSkrJyIgZnJvbSAiJytILkVqKGIp
+KyciLicpKQpwPXQuTgpDLk5tLlVHKHEuZCwwLFAuTzgoci5kLmxlbmd0aCwiLi4iLCExLHApKQpDLk5t
+Llk1KHEuZSwwLCIiKQpDLk5tLlVHKHEuZSwxLFAuTzgoci5kLmxlbmd0aCxzLmdtSSgpLCExLHApKQpz
+PXEuZApwPXMubGVuZ3RoCmlmKHA9PT0wKXJldHVybiIuIgppZihwPjEmJkouUk0oQy5ObS5ncloocyks
+Ii4iKSl7cz1xLmQKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpzPXEuZQpp
+ZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCmlmKDA+PXMubGVuZ3RoKXJldHVy
+biBILk9IKHMsLTEpCnMucG9wKCkKQy5ObS5pKHMsIiIpfXEuYj0iIgpxLkl4KCkKcmV0dXJuIHEudygw
+KX19Ck0ucTcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEguaChhKSE9PSIifSwKJFM6
+N30KTS5Oby5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILmsoYSkKcmV0dXJuIGE9PW51bGw/Im51
+bGwiOiciJythKyciJ30sCiRTOjUxfQpCLmZ2LnByb3RvdHlwZT17CnhaOmZ1bmN0aW9uKGEpe3ZhciBz
+LHI9dGhpcy5ZcihhKQppZihyPjApcmV0dXJuIEoubGQoYSwwLHIpCmlmKHRoaXMuaEsoYSkpe2lmKDA+
+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsMCkKcz1hWzBdfWVsc2Ugcz1udWxsCnJldHVybiBzfSwKTmM6
+ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYT09Yn19ClguV0QucHJvdG90eXBlPXsKSXg6ZnVuY3Rpb24oKXt2
+YXIgcyxyLHE9dGhpcwp3aGlsZSghMCl7cz1xLmQKaWYoIShzLmxlbmd0aCE9PTAmJkouUk0oQy5ObS5n
+cloocyksIiIpKSlicmVhawpzPXEuZAppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBv
+cCgpCnM9cS5lCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCl9cz1xLmUKcj1z
+Lmxlbmd0aAppZihyIT09MClDLk5tLlk1KHMsci0xLCIiKX0sCnJSOmZ1bmN0aW9uKCl7dmFyIHMscixx
+LHAsbyxuLG09dGhpcyxsPUguUUkoW10sdC5zKQpmb3Iocz1tLmQscj1zLmxlbmd0aCxxPTAscD0wO3A8
+cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Ape289c1twXQpuPUouaWEobykKaWYo
+IShuLkROKG8sIi4iKXx8bi5ETihvLCIiKSkpaWYobi5ETihvLCIuLiIpKXtuPWwubGVuZ3RoCmlmKG4h
+PT0wKXtpZigwPj1uKXJldHVybiBILk9IKGwsLTEpCmwucG9wKCl9ZWxzZSArK3F9ZWxzZSBDLk5tLmko
+bCxvKX1pZihtLmI9PW51bGwpQy5ObS5VRyhsLDAsUC5POChxLCIuLiIsITEsdC5OKSkKaWYobC5sZW5n
+dGg9PT0wJiZtLmI9PW51bGwpQy5ObS5pKGwsIi4iKQptLnNuSihsKQpzPW0uYQptLnNQaChQLk84KGwu
+bGVuZ3RoKzEscy5nbUkoKSwhMCx0Lk4pKQpyPW0uYgppZihyPT1udWxsfHxsLmxlbmd0aD09PTB8fCFz
+LmRzKHIpKUMuTm0uWTUobS5lLDAsIiIpCnI9bS5iCmlmKHIhPW51bGwmJnM9PT0kLktrKCkpe3IudG9T
+dHJpbmcKbS5iPUgueXMociwiLyIsIlxcIil9bS5JeCgpfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9
+dGhpcyxwPXEuYgpwPXAhPW51bGw/cDoiIgpmb3Iocz0wO3M8cS5kLmxlbmd0aDsrK3Mpe3I9cS5lCmlm
+KHM+PXIubGVuZ3RoKXJldHVybiBILk9IKHIscykKcj1wK0guRWoocltzXSkKcD1xLmQKaWYocz49cC5s
+ZW5ndGgpcmV0dXJuIEguT0gocCxzKQpwPXIrSC5FaihwW3NdKX1wKz1ILkVqKEMuTm0uZ3JaKHEuZSkp
+CnJldHVybiBwLmNoYXJDb2RlQXQoMCk9PTA/cDpwfSwKc25KOmZ1bmN0aW9uKGEpe3RoaXMuZD10LkQu
+YShhKX0sCnNQaDpmdW5jdGlvbihhKXt0aGlzLmU9dC5ELmEoYSl9fQpYLmR2LnByb3RvdHlwZT17Cnc6
+ZnVuY3Rpb24oYSl7cmV0dXJuIlBhdGhFeGNlcHRpb246ICIrdGhpcy5hfSwKJGlSejoxfQpPLnpMLnBy
+b3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ29jKHRoaXMpfX0KRS5PRi5wcm90b3R5
+cGU9ewpVZDpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihhKXty
+ZXR1cm4gYT09PTQ3fSwKZHM6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKcmV0dXJuIHMhPT0wJiZD
+LnhCLk8oYSxzLTEpIT09NDd9LApTcDpmdW5jdGlvbihhLGIpe2lmKGEubGVuZ3RoIT09MCYmQy54Qi5X
+KGEsMCk9PT00NylyZXR1cm4gMQpyZXR1cm4gMH0sCllyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlNw
+KGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuITF9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4icG9z
+aXgifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJuIi8ifX0KRi5ydS5wcm90b3R5cGU9ewpVZDpmdW5jdGlv
+bihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihhKXtyZXR1cm4gYT09PTQ3fSwK
+ZHM6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKaWYoQy54Qi5PKGEs
+cy0xKSE9PTQ3KXJldHVybiEwCnJldHVybiBDLnhCLlRjKGEsIjovLyIpJiZ0aGlzLllyKGEpPT09c30s
+ClNwOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz1hLmxlbmd0aAppZihvPT09MClyZXR1cm4gMApp
+ZihDLnhCLlcoYSwwKT09PTQ3KXJldHVybiAxCmZvcihzPTA7czxvOysrcyl7cj1DLnhCLlcoYSxzKQpp
+ZihyPT09NDcpcmV0dXJuIDAKaWYocj09PTU4KXtpZihzPT09MClyZXR1cm4gMApxPUMueEIuWFUoYSwi
+LyIsQy54Qi5RaShhLCIvLyIscysxKT9zKzM6cykKaWYocTw9MClyZXR1cm4gbwppZighYnx8bzxxKzMp
+cmV0dXJuIHEKaWYoIUMueEIubkMoYSwiZmlsZTovLyIpKXJldHVybiBxCmlmKCFCLll1KGEscSsxKSly
+ZXR1cm4gcQpwPXErMwpyZXR1cm4gbz09PXA/cDpxKzR9fXJldHVybiAwfSwKWXI6ZnVuY3Rpb24oYSl7
+cmV0dXJuIHRoaXMuU3AoYSwhMSl9LApoSzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGghPT0wJiZD
+LnhCLlcoYSwwKT09PTQ3fSwKZ29jOmZ1bmN0aW9uKCl7cmV0dXJuInVybCJ9LApnbUk6ZnVuY3Rpb24o
+KXtyZXR1cm4iLyJ9fQpMLklWLnByb3RvdHlwZT17ClVkOmZ1bmN0aW9uKGEpe3JldHVybiBDLnhCLnRn
+KGEsIi8iKX0sCnI0OmZ1bmN0aW9uKGEpe3JldHVybiBhPT09NDd8fGE9PT05Mn0sCmRzOmZ1bmN0aW9u
+KGEpe3ZhciBzPWEubGVuZ3RoCmlmKHM9PT0wKXJldHVybiExCnM9Qy54Qi5PKGEscy0xKQpyZXR1cm4h
+KHM9PT00N3x8cz09PTkyKX0sClNwOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWEubGVuZ3RoCmlmKHE9
+PT0wKXJldHVybiAwCnM9Qy54Qi5XKGEsMCkKaWYocz09PTQ3KXJldHVybiAxCmlmKHM9PT05Mil7aWYo
+cTwyfHxDLnhCLlcoYSwxKSE9PTkyKXJldHVybiAxCnI9Qy54Qi5YVShhLCJcXCIsMikKaWYocj4wKXty
+PUMueEIuWFUoYSwiXFwiLHIrMSkKaWYocj4wKXJldHVybiByfXJldHVybiBxfWlmKHE8MylyZXR1cm4g
+MAppZighQi5PUyhzKSlyZXR1cm4gMAppZihDLnhCLlcoYSwxKSE9PTU4KXJldHVybiAwCnE9Qy54Qi5X
+KGEsMikKaWYoIShxPT09NDd8fHE9PT05MikpcmV0dXJuIDAKcmV0dXJuIDN9LApZcjpmdW5jdGlvbihh
+KXtyZXR1cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLllyKGEpPT09
+MX0sCk90OmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYT09PWIpcmV0dXJuITAKaWYoYT09PTQ3KXJldHVy
+biBiPT09OTIKaWYoYT09PTkyKXJldHVybiBiPT09NDcKaWYoKGFeYikhPT0zMilyZXR1cm4hMQpzPWF8
+MzIKcmV0dXJuIHM+PTk3JiZzPD0xMjJ9LApOYzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQppZihhPT1i
+KXJldHVybiEwCnM9YS5sZW5ndGgKaWYocyE9PWIubGVuZ3RoKXJldHVybiExCmZvcihyPUouclkoYiks
+cT0wO3E8czsrK3EpaWYoIXRoaXMuT3QoQy54Qi5XKGEscSksci5XKGIscSkpKXJldHVybiExCnJldHVy
+biEwfSwKZ29jOmZ1bmN0aW9uKCl7cmV0dXJuIndpbmRvd3MifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJu
+IlxcIn19OyhmdW5jdGlvbiBhbGlhc2VzKCl7dmFyIHM9Si5Hdi5wcm90b3R5cGUKcy5VPXMudwpzLlNq
+PXMuZTcKcz1KLk1GLnByb3RvdHlwZQpzLnQ9cy53CnM9UC5jWC5wcm90b3R5cGUKcy5HRz1zLmV2CnM9
+UC5NaC5wcm90b3R5cGUKcy54Yj1zLncKcz1XLmN2LnByb3RvdHlwZQpzLkRXPXMucjYKcz1XLm02LnBy
+b3RvdHlwZQpzLmpGPXMuRWIKcz1QLkU0LnByb3RvdHlwZQpzLlVyPXMucQpzLmU0PXMuWTUKcz1QLnZn
+LnByb3RvdHlwZQpzLmJoPXMuWTV9KSgpOyhmdW5jdGlvbiBpbnN0YWxsVGVhck9mZnMoKXt2YXIgcz1o
+dW5rSGVscGVycy5fc3RhdGljXzEscj1odW5rSGVscGVycy5fc3RhdGljXzAscT1odW5rSGVscGVycy5p
+bnN0YWxsSW5zdGFuY2VUZWFyT2ZmLHA9aHVua0hlbHBlcnMuaW5zdGFsbFN0YXRpY1RlYXJPZmYsbz1o
+dW5rSGVscGVycy5faW5zdGFuY2VfMXUKcyhQLCJFWCIsIlpWIiw4KQpzKFAsInl0Iiwib0EiLDgpCnMo
+UCwicVciLCJCeiIsOCkKcihQLCJVSSIsImVOIiwwKQpxKFAuUGYucHJvdG90eXBlLCJnWUoiLDAsMSxu
+dWxsLFsiJDIiLCIkMSJdLFsidzAiLCJwbSJdLDI2LDAsMCkKcyhQLCJDeSIsIk5DIiw0KQpzKFAsIlBI
+IiwiTXQiLDUpCnAoVywicFMiLDQsbnVsbCxbIiQ0Il0sWyJxRCJdLDksMCkKcChXLCJWNCIsNCxudWxs
+LFsiJDQiXSxbIm5aIl0sOSwwKQpvKFAuQXMucHJvdG90eXBlLCJndU0iLCJWIiw1KQpzKFAsImlHIiwi
+d1kiLDU0KQpzKFAsIncwIiwiZFUiLDM2KQpzKEwsImlTIiwiaTYiLDYpfSkoKTsoZnVuY3Rpb24gaW5o
+ZXJpdGFuY2UoKXt2YXIgcz1odW5rSGVscGVycy5taXhpbixyPWh1bmtIZWxwZXJzLmluaGVyaXQscT1o
+dW5rSGVscGVycy5pbmhlcml0TWFueQpyKFAuTWgsbnVsbCkKcShQLk1oLFtILkZLLEouR3YsSi5tMSxQ
+LmNYLEguRTcsUC5YUyxQLm5ZLEguYTcsUC5BbixILkZ1LEguSkIsSC5TVSxILlJlLEgud3YsUC5QbixI
+LldVLEguTEksSC5UcCxILmY5LEgudGUsSC5icSxILlhPLEgua3IsUC5ZayxILnZoLEguTjYsSC5WUixI
+LkVLLEguUGIsSC50USxILlNkLEguSmMsSC5HLEgubFksUC5XMyxQLmloLFAuRnksUC5HVixQLkN3LFAu
+UGYsUC5GZSxQLnZzLFAuT00sUC5xaCxQLk1PLFAua1QsUC54SSxQLm0wLFAucFIsUC5ibixQLmxtLFAu
+bEQsUC5LUCxQLmxmLFAuV1ksUC5VayxQLlNoLFAuUncsUC5ieixQLmlQLFAuazUsUC5LWSxQLkNELFAu
+YUUsUC5OMyxQLmM4LFAuWmQsUC5NLFAuRG4sUC5QRSxQLlVmLFcuaWQsVy5GayxXLkpRLFcuR20sVy52
+RCxXLm02LFcuT3csVy5XOSxXLmRXLFcubWssVy5LbyxQLmlKLFAuRTQsVS5kMixVLlNlLFUuTWwsVS55
+RCxVLndiLEIuajgsQi5xcCxULm1RLEwuWEEsTC5EOCxMLk85LEwuR2IsUi5MTCxSLkg3LE0ubEksTy56
+TCxYLldELFguZHZdKQpxKEouR3YsW0oueUUsSi53ZSxKLk1GLEouamQsSi5xSSxKLkRyLEguRVQsVy5E
+MCxXLkF6LFcuTGUsVy5OaCxXLmFlLFcuSUIsVy5OUSxXLmVhLFcuYnIsVy5TZyxXLnc3LFcuSzcsVy5Y
+VyxQLmhGXSkKcShKLk1GLFtKLmlDLEoua2QsSi5jNV0pCnIoSi5QbyxKLmpkKQpxKEoucUksW0ouYlUs
+Si5rRF0pCnEoUC5jWCxbSC5CUixILmJRLEguaTEsSC5VNSxILkFNLEgudTYsSC5YUixQLm1XLEgudW5d
+KQpxKEguQlIsW0guWnksSC5RQ10pCnIoSC5vbCxILlp5KQpyKEguVXEsSC5RQykKcihILmpWLEguVXEp
+CnEoUC5YUyxbSC5uLEgucjMsSC5HTSxQLkV6LEguYXosSC52VixILkVxLFAuQzYsSC5rUyxQLlVkLFAu
+TEssUC5jLFAubXAsUC51YixQLmRzLFAubGosUC5VVixQLnQ3LEwuUVddKQpyKFAudXksUC5uWSkKcShQ
+LnV5LFtILncyLFcud3osVy5lN10pCnIoSC5xaixILncyKQpxKEguYlEsW0guYUwsSC5NQixILmk1XSkK
+cShILmFMLFtILm5ILEgubEosUC5pOF0pCnIoSC54eSxILmkxKQpxKFAuQW4sW0guTUgsSC5TTyxILlUx
+XSkKcihILmQ1LEguQU0pCnIoUC5SVSxQLlBuKQpyKFAuR2osUC5SVSkKcihILlBELFAuR2opCnIoSC5M
+UCxILldVKQpxKEguVHAsW0guQ2osSC5sYyxILmRDLEgud04sSC5WWCxQLnRoLFAuaGEsUC5WcyxQLkZ0
+LFAueUgsUC5XTSxQLlNYLFAuR3MsUC5kYSxQLm9RLFAucFYsUC5VNyxQLnZyLFAucnQsUC5LRixQLlpM
+LFAuUlQsUC5qWixQLnJxLFAuUlcsUC5CNSxQLnVPLFAuRXYsUC5WcCxQLk9SLFAucmEsUC55USxQLnhy
+LFAuTnosUC50aSxQLldGLFAubjEsUC5jUyxQLlZDLFAuSlQsUC5SWixQLk1FLFAueTUsUC55SSxQLmM2
+LFAucWQsVy5DdixXLktTLFcuQTMsVy52TixXLlV2LFcuRWcsVy5FbyxXLldrLFcuSUEsVy5mbSxQLkUy
+LFAuamcsUC5HRSxQLk43LFAudVEsUC5QQyxQLm10LFAuUVMsUC5ucCxQLlV0LFUuYU4sVS5iMCxMLmUs
+TC5WVyxMLm9aLEwuanIsTC5xbCxMLkhpLEwuQlQsTC5QWSxMLnU4LEwuTCxMLld4LEwuQU8sTC5kTixM
+LkhvLEwueHosTC5JQyxMLmZDLEwuVG0sTC5uVCxMLk5ZLEwudWUsTC5lWCxMLkVFLEwuUUwsTC5WUyxM
+LlRELEwuSWYsTC50QixMLm0yLFIuTUQsTS5xNyxNLk5vXSkKcihILlcwLFAuRXopCnEoSC5sYyxbSC56
+eCxILnJUXSkKcihILmtZLFAuQzYpCnIoUC5pbCxQLllrKQpxKFAuaWwsW0guTjUsUC51dyxXLmNmLFcu
+U3ldKQpxKFAubVcsW0guS1csUC5xNF0pCnIoSC5MWixILkVUKQpxKEguTFosW0guUkcsSC5XQl0pCnIo
+SC5WUCxILlJHKQpyKEguRGcsSC5WUCkKcihILlpHLEguV0IpCnIoSC5QZyxILlpHKQpxKEguUGcsW0gu
+eGosSC5kRSxILlpBLEguZFQsSC5QcSxILmVFLEguVjZdKQpyKEguaU0sSC5rUykKcihQLlpmLFAuUGYp
+CnIoUC5KaSxQLm0wKQpyKFAuWHYsUC5wUikKcihQLmI2LFAuWHYpCnIoUC5WaixQLldZKQpxKFAuVWss
+W1AuQ1YsUC5aaSxQLmJ5XSkKcihQLndJLFAua1QpCnEoUC53SSxbUC5VOCxQLm9qLFAuTXgsUC5FMyxQ
+LkdZXSkKcihQLks4LFAuVWQpCnIoUC50dSxQLlNoKQpyKFAudTUsUC5aaSkKcShQLmMsW1AuYkosUC5l
+WV0pCnIoUC5xZSxQLkRuKQpxKFcuRDAsW1cudUgsVy53YSxXLks1LFcuQ21dKQpxKFcudUgsW1cuY3Ys
+Vy5ueCxXLlFGLFcuQ1FdKQpxKFcuY3YsW1cucUUsUC5oaV0pCnEoVy5xRSxbVy5HaCxXLmZZLFcuclos
+Vy5RUCxXLmg0LFcuU04sVy5scCxXLlRiLFcuSXYsVy5XUCxXLnlZXSkKcihXLm9KLFcuTGUpCnIoVy5o
+SCxXLkF6KQpyKFcuVmIsVy5RRikKcihXLmZKLFcud2EpCnEoVy5lYSxbVy53NixXLmV3XSkKcihXLkFq
+LFcudzYpCnIoVy5yQixXLks3KQpyKFcuQkgsVy5yQikKcihXLnc0LFcuSUIpCnIoVy5vYSxXLlhXKQpy
+KFcucmgsVy5vYSkKcihXLmk3LFcuY2YpCnIoUC5BcyxQLlZqKQpxKFAuQXMsW1cuSTQsUC5LZV0pCnIo
+Vy5STyxQLnFoKQpyKFcuZXUsVy5STykKcihXLnhDLFAuTU8pCnIoVy5jdCxXLm02KQpyKFAuQmYsUC5p
+SikKcShQLkU0LFtQLnI3LFAudmddKQpyKFAuVHosUC52ZykKcihQLm5kLFAuaGkpCnEoTC5EOCxbTC52
+dCxMLmNEXSkKcihCLmZ2LE8uekwpCnEoQi5mdixbRS5PRixGLnJ1LEwuSVZdKQpzKEgudzIsSC5SZSkK
+cyhILlFDLFAubEQpCnMoSC5SRyxQLmxEKQpzKEguVlAsSC5TVSkKcyhILldCLFAubEQpCnMoSC5aRyxI
+LlNVKQpzKFAublksUC5sRCkKcyhQLldZLFAubGYpCnMoUC5SVSxQLktQKQpzKFAucFIsUC5sZikKcyhX
+LkxlLFcuaWQpCnMoVy5LNyxQLmxEKQpzKFcuckIsVy5HbSkKcyhXLlhXLFAubEQpCnMoVy5vYSxXLkdt
+KQpzKFAudmcsUC5sRCl9KSgpCnZhciB2PXt0eXBlVW5pdmVyc2U6e2VDOm5ldyBNYXAoKSx0Ujp7fSxl
+VDp7fSx0UFY6e30sc0VBOltdfSxtYW5nbGVkR2xvYmFsTmFtZXM6e0lqOiJpbnQiLENQOiJkb3VibGUi
+LFpaOiJudW0iLHFVOiJTdHJpbmciLGEyOiJib29sIixjODoiTnVsbCIsek06Ikxpc3QifSxtYW5nbGVk
+TmFtZXM6e30sdHlwZXM6WyJ+KCkiLCJjOChBaiopIiwiYzgoKSIsImM4KGN2KikiLCJAKEApIiwicVUo
+cVUpIiwifihBaiopIiwiYTIocVUpIiwifih+KCkpIiwiYTIoY3YscVUscVUsSlEpIiwiYzgoQCkiLCJ+
+KE1oPyxNaD8pIiwiQCgpIiwifihxVSxAKSIsIn4objYscVUsSWopIiwifihxVSxxVSkiLCJhMihrRiki
+LCJjOChALEApIiwifih4dTxxVT4pIiwiYzgoZWEqKSIsImI4PGM4PiooQWoqKSIsIn4ocVUsSWopIiwi
+fihxVSxxVT8pIiwibjYoQCxAKSIsIn4oSWosQCkiLCJhMih1SCkiLCJ+KE1oW0d6P10pIiwifihlYSki
+LCJjOChNaCxHeikiLCJ2czxAPihAKSIsIn4odUgsdUg/KSIsIn4oQCxAKSIsIkAocVUpIiwiYTIoeHU8
+cVU+KSIsIkAoQCxxVSkiLCJyNyhAKSIsIk1oPyhAKSIsIkU0KEApIiwiTEwqKEApIiwiWjA8cVUqLE1o
+Kj4qKExMKikiLCJ+KEdELEApIiwiWjA8cVUscVU+KFowPHFVLHFVPixxVSkiLCJjOChaMDxxVSosTWgq
+PiopIiwifihAKSIsInFVKihBaiopIiwifihxVVtAXSkiLCJUejxAPihAKSIsImM4KGV3KikiLCJxVSoo
+cVUqKSIsInFVKihaMDxALEA+KikiLCJhMiooSDcqKSIsInFVKHFVPykiLCJJaihJaixJaikiLCJjOCh+
+KCkpIiwiTWg/KE1oPykiLCJjOChALEd6KSJdLGludGVyY2VwdG9yc0J5VGFnOm51bGwsbGVhZlRhZ3M6
+bnVsbCxhcnJheVJ0aTp0eXBlb2YgU3ltYm9sPT0iZnVuY3Rpb24iJiZ0eXBlb2YgU3ltYm9sKCk9PSJz
+eW1ib2wiP1N5bWJvbCgiJHRpIik6IiR0aSJ9CkgueGIodi50eXBlVW5pdmVyc2UsSlNPTi5wYXJzZSgn
+eyJpQyI6Ik1GIiwia2QiOiJNRiIsImM1IjoiTUYiLCJyeCI6ImVhIiwiZTUiOiJlYSIsIlkwIjoiaGki
+LCJ0cCI6ImhpIiwiRzgiOiJldyIsIk1yIjoicUUiLCJlTCI6InFFIiwiSTAiOiJ1SCIsImhzIjoidUgi
+LCJYZyI6IlFGIiwibnIiOiJBaiIsInk0IjoidzYiLCJhUCI6IkNtIiwieGMiOiJueCIsImtKIjoibngi
+LCJ6VSI6IkRnIiwiZGYiOiJFVCIsInlFIjp7ImEyIjpbXX0sIndlIjp7ImM4IjpbXX0sIk1GIjp7InZt
+IjpbXX0sImpkIjp7InpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJQbyI6eyJqZCI6WyIx
+Il0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJtMSI6eyJBbiI6WyIxIl19LCJxSSI6
+eyJDUCI6W10sIlpaIjpbXX0sImJVIjp7IkNQIjpbXSwiSWoiOltdLCJaWiI6W119LCJrRCI6eyJDUCI6
+W10sIlpaIjpbXX0sIkRyIjp7InFVIjpbXSwidlgiOltdfSwiYlEiOnsiY1giOlsiMSJdfSwiQlIiOnsi
+Y1giOlsiMiJdfSwiRTciOnsiQW4iOlsiMiJdfSwiWnkiOnsiQlIiOlsiMSIsIjIiXSwiY1giOlsiMiJd
+LCJjWC5FIjoiMiJ9LCJvbCI6eyJaeSI6WyIxIiwiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0s
+ImNYIjpbIjIiXSwiY1guRSI6IjIifSwiVXEiOnsibEQiOlsiMiJdLCJ6TSI6WyIyIl0sIkJSIjpbIjEi
+LCIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdfSwialYiOnsiVXEiOlsiMSIsIjIiXSwibEQiOlsiMiJd
+LCJ6TSI6WyIyIl0sIkJSIjpbIjEiLCIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdLCJsRC5FIjoiMiIs
+ImNYLkUiOiIyIn0sIm4iOnsiWFMiOltdfSwicjMiOnsiWFMiOltdfSwicWoiOnsibEQiOlsiSWoiXSwi
+UmUiOlsiSWoiXSwiek0iOlsiSWoiXSwiYlEiOlsiSWoiXSwiY1giOlsiSWoiXSwibEQuRSI6IklqIiwi
+UmUuRSI6IklqIn0sIkdNIjp7IlhTIjpbXX0sImFMIjp7ImJRIjpbIjEiXSwiY1giOlsiMSJdfSwibkgi
+OnsiYUwiOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwiYUwuRSI6IjEiLCJjWC5FIjoiMSJ9LCJh
+NyI6eyJBbiI6WyIxIl19LCJpMSI6eyJjWCI6WyIyIl0sImNYLkUiOiIyIn0sInh5Ijp7ImkxIjpbIjEi
+LCIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdLCJjWC5FIjoiMiJ9LCJNSCI6eyJBbiI6WyIyIl19LCJs
+SiI6eyJhTCI6WyIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdLCJhTC5FIjoiMiIsImNYLkUiOiIyIn0s
+IlU1Ijp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiU08iOnsiQW4iOlsiMSJdfSwiQU0iOnsiY1giOlsi
+MSJdLCJjWC5FIjoiMSJ9LCJkNSI6eyJBTSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdLCJjWC5F
+IjoiMSJ9LCJVMSI6eyJBbiI6WyIxIl19LCJNQiI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXSwiY1guRSI6
+IjEifSwiRnUiOnsiQW4iOlsiMSJdfSwidTYiOnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJKQiI6eyJB
+biI6WyIxIl19LCJ3MiI6eyJsRCI6WyIxIl0sIlJlIjpbIjEiXSwiek0iOlsiMSJdLCJiUSI6WyIxIl0s
+ImNYIjpbIjEiXX0sInd2Ijp7IkdEIjpbXX0sIlBEIjp7IkdqIjpbIjEiLCIyIl0sIlJVIjpbIjEiLCIy
+Il0sIlBuIjpbIjEiLCIyIl0sIktQIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19LCJXVSI6eyJaMCI6
+WyIxIiwiMiJdfSwiTFAiOnsiV1UiOlsiMSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIlhSIjp7ImNYIjpb
+IjEiXSwiY1guRSI6IjEifSwiTEkiOnsidlEiOltdfSwiVzAiOnsiWFMiOltdfSwiYXoiOnsiWFMiOltd
+fSwidlYiOnsiWFMiOltdfSwidGUiOnsiUnoiOltdfSwiWE8iOnsiR3oiOltdfSwiVHAiOnsiRUgiOltd
+fSwibGMiOnsiRUgiOltdfSwiengiOnsiRUgiOltdfSwiclQiOnsiRUgiOltdfSwiRXEiOnsiWFMiOltd
+fSwia1kiOnsiWFMiOltdfSwiTjUiOnsiWWsiOlsiMSIsIjIiXSwiRm8iOlsiMSIsIjIiXSwiWjAiOlsi
+MSIsIjIiXSwiWWsuSyI6IjEiLCJZay5WIjoiMiJ9LCJpNSI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXSwi
+Y1guRSI6IjEifSwiTjYiOnsiQW4iOlsiMSJdfSwiVlIiOnsid0wiOltdLCJ2WCI6W119LCJFSyI6eyJp
+YiI6W10sIk9kIjpbXX0sIktXIjp7ImNYIjpbImliIl0sImNYLkUiOiJpYiJ9LCJQYiI6eyJBbiI6WyJp
+YiJdfSwidFEiOnsiT2QiOltdfSwidW4iOnsiY1giOlsiT2QiXSwiY1guRSI6Ik9kIn0sIlNkIjp7IkFu
+IjpbIk9kIl19LCJFVCI6eyJBUyI6W119LCJMWiI6eyJYaiI6WyIxIl0sIkVUIjpbXSwiQVMiOltdfSwi
+RGciOnsibEQiOlsiQ1AiXSwiWGoiOlsiQ1AiXSwiek0iOlsiQ1AiXSwiRVQiOltdLCJiUSI6WyJDUCJd
+LCJBUyI6W10sImNYIjpbIkNQIl0sIlNVIjpbIkNQIl0sImxELkUiOiJDUCJ9LCJQZyI6eyJsRCI6WyJJ
+aiJdLCJYaiI6WyJJaiJdLCJ6TSI6WyJJaiJdLCJFVCI6W10sImJRIjpbIklqIl0sIkFTIjpbXSwiY1gi
+OlsiSWoiXSwiU1UiOlsiSWoiXX0sInhqIjp7ImxEIjpbIklqIl0sIlhqIjpbIklqIl0sInpNIjpbIklq
+Il0sIkVUIjpbXSwiYlEiOlsiSWoiXSwiQVMiOltdLCJjWCI6WyJJaiJdLCJTVSI6WyJJaiJdLCJsRC5F
+IjoiSWoifSwiZEUiOnsibEQiOlsiSWoiXSwiWGoiOlsiSWoiXSwiek0iOlsiSWoiXSwiRVQiOltdLCJi
+USI6WyJJaiJdLCJBUyI6W10sImNYIjpbIklqIl0sIlNVIjpbIklqIl0sImxELkUiOiJJaiJ9LCJaQSI6
+eyJsRCI6WyJJaiJdLCJYaiI6WyJJaiJdLCJ6TSI6WyJJaiJdLCJFVCI6W10sImJRIjpbIklqIl0sIkFT
+IjpbXSwiY1giOlsiSWoiXSwiU1UiOlsiSWoiXSwibEQuRSI6IklqIn0sImRUIjp7ImxEIjpbIklqIl0s
+IlhqIjpbIklqIl0sInpNIjpbIklqIl0sIkVUIjpbXSwiYlEiOlsiSWoiXSwiQVMiOltdLCJjWCI6WyJJ
+aiJdLCJTVSI6WyJJaiJdLCJsRC5FIjoiSWoifSwiUHEiOnsibEQiOlsiSWoiXSwiWGoiOlsiSWoiXSwi
+ek0iOlsiSWoiXSwiRVQiOltdLCJiUSI6WyJJaiJdLCJBUyI6W10sImNYIjpbIklqIl0sIlNVIjpbIklq
+Il0sImxELkUiOiJJaiJ9LCJlRSI6eyJsRCI6WyJJaiJdLCJYaiI6WyJJaiJdLCJ6TSI6WyJJaiJdLCJF
+VCI6W10sImJRIjpbIklqIl0sIkFTIjpbXSwiY1giOlsiSWoiXSwiU1UiOlsiSWoiXSwibEQuRSI6Iklq
+In0sIlY2Ijp7ImxEIjpbIklqIl0sIm42IjpbXSwiWGoiOlsiSWoiXSwiek0iOlsiSWoiXSwiRVQiOltd
+LCJiUSI6WyJJaiJdLCJBUyI6W10sImNYIjpbIklqIl0sIlNVIjpbIklqIl0sImxELkUiOiJJaiJ9LCJr
+UyI6eyJYUyI6W119LCJpTSI6eyJYUyI6W119LCJ2cyI6eyJiOCI6WyIxIl19LCJHViI6eyJBbiI6WyIx
+Il19LCJxNCI6eyJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkN3Ijp7IlhTIjpbXX0sIlpmIjp7IlBmIjpb
+IjEiXX0sIm0wIjp7IlFtIjpbXX0sIkppIjp7Im0wIjpbXSwiUW0iOltdfSwiYjYiOnsibGYiOlsiMSJd
+LCJ4dSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdLCJsZi5FIjoiMSJ9LCJsbSI6eyJBbiI6WyIx
+Il19LCJtVyI6eyJjWCI6WyIxIl19LCJ1eSI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJd
+LCJjWCI6WyIxIl19LCJpbCI6eyJZayI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiWWsiOnsiWjAi
+OlsiMSIsIjIiXX0sIlBuIjp7IlowIjpbIjEiLCIyIl19LCJHaiI6eyJSVSI6WyIxIiwiMiJdLCJQbiI6
+WyIxIiwiMiJdLCJLUCI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiVmoiOnsibGYiOlsiMSJdLCJ4
+dSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiWHYiOnsibGYiOlsiMSJdLCJ4dSI6WyIxIl0s
+ImJRIjpbIjEiXSwiY1giOlsiMSJdfSwidXciOnsiWWsiOlsicVUiLCJAIl0sIlowIjpbInFVIiwiQCJd
+LCJZay5LIjoicVUiLCJZay5WIjoiQCJ9LCJpOCI6eyJhTCI6WyJxVSJdLCJiUSI6WyJxVSJdLCJjWCI6
+WyJxVSJdLCJhTC5FIjoicVUiLCJjWC5FIjoicVUifSwiQ1YiOnsiVWsiOlsiek08SWo+IiwicVUiXSwi
+VWsuUyI6InpNPElqPiJ9LCJVOCI6eyJ3SSI6WyJ6TTxJaj4iLCJxVSJdfSwiWmkiOnsiVWsiOlsicVUi
+LCJ6TTxJaj4iXX0sIlVkIjp7IlhTIjpbXX0sIks4Ijp7IlhTIjpbXX0sImJ5Ijp7IlVrIjpbIk1oPyIs
+InFVIl0sIlVrLlMiOiJNaD8ifSwib2oiOnsid0kiOlsiTWg/IiwicVUiXX0sIk14Ijp7IndJIjpbInFV
+IiwiTWg/Il19LCJ1NSI6eyJVayI6WyJxVSIsInpNPElqPiJdLCJVay5TIjoicVUifSwiRTMiOnsid0ki
+OlsicVUiLCJ6TTxJaj4iXX0sIkdZIjp7IndJIjpbInpNPElqPiIsInFVIl19LCJDUCI6eyJaWiI6W119
+LCJJaiI6eyJaWiI6W119LCJ6TSI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXX0sImliIjp7Ik9kIjpbXX0s
+Inh1Ijp7ImJRIjpbIjEiXSwiY1giOlsiMSJdfSwicVUiOnsidlgiOltdfSwiQzYiOnsiWFMiOltdfSwi
+RXoiOnsiWFMiOltdfSwiTEsiOnsiWFMiOltdfSwiYyI6eyJYUyI6W119LCJiSiI6eyJYUyI6W119LCJl
+WSI6eyJYUyI6W119LCJtcCI6eyJYUyI6W119LCJ1YiI6eyJYUyI6W119LCJkcyI6eyJYUyI6W119LCJs
+aiI6eyJYUyI6W119LCJVViI6eyJYUyI6W119LCJrNSI6eyJYUyI6W119LCJLWSI6eyJYUyI6W119LCJ0
+NyI6eyJYUyI6W119LCJDRCI6eyJSeiI6W119LCJhRSI6eyJSeiI6W119LCJaZCI6eyJHeiI6W119LCJN
+Ijp7IkJMIjpbXX0sIkRuIjp7ImlEIjpbXX0sIlVmIjp7ImlEIjpbXX0sInFlIjp7ImlEIjpbXX0sImN2
+Ijp7InVIIjpbXSwiRDAiOltdfSwiZkoiOnsiRDAiOltdfSwid2EiOnsiRDAiOltdfSwiQWoiOnsiZWEi
+OltdfSwidUgiOnsiRDAiOltdfSwiZXciOnsiZWEiOltdfSwidzYiOnsiZWEiOltdfSwiSlEiOnsia0Yi
+OltdfSwicUUiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIkdoIjp7ImN2IjpbXSwidUgiOltdLCJE
+MCI6W119LCJmWSI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwicloiOnsiY3YiOltdLCJ1SCI6W10s
+IkQwIjpbXX0sIlFQIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJueCI6eyJ1SCI6W10sIkQwIjpb
+XX0sIlFGIjp7InVIIjpbXSwiRDAiOltdfSwiSUIiOnsidG4iOlsiWloiXX0sInd6Ijp7ImxEIjpbIjEi
+XSwiek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwibEQuRSI6IjEifSwiaEgiOnsiQXoiOltd
+fSwiaDQiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlZiIjp7InVIIjpbXSwiRDAiOltdfSwiZTci
+OnsibEQiOlsidUgiXSwiek0iOlsidUgiXSwiYlEiOlsidUgiXSwiY1giOlsidUgiXSwibEQuRSI6InVI
+In0sIkJIIjp7ImxEIjpbInVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJR
+IjpbInVIIl0sImNYIjpbInVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJTTiI6eyJjdiI6W10s
+InVIIjpbXSwiRDAiOltdfSwibHAiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlRiIjp7ImN2Ijpb
+XSwidUgiOltdLCJEMCI6W119LCJJdiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiV1AiOnsiY3Yi
+OltdLCJ1SCI6W10sIkQwIjpbXX0sInlZIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJLNSI6eyJ2
+NiI6W10sIkQwIjpbXX0sIkNtIjp7IkQwIjpbXX0sIkNRIjp7InVIIjpbXSwiRDAiOltdfSwidzQiOnsi
+dG4iOlsiWloiXX0sInJoIjp7ImxEIjpbInVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpb
+InVIIl0sImJRIjpbInVIIl0sImNYIjpbInVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJjZiI6
+eyJZayI6WyJxVSIsInFVIl0sIlowIjpbInFVIiwicVUiXX0sImk3Ijp7IllrIjpbInFVIiwicVUiXSwi
+WjAiOlsicVUiLCJxVSJdLCJZay5LIjoicVUiLCJZay5WIjoicVUifSwiU3kiOnsiWWsiOlsicVUiLCJx
+VSJdLCJaMCI6WyJxVSIsInFVIl0sIllrLksiOiJxVSIsIllrLlYiOiJxVSJ9LCJJNCI6eyJsZiI6WyJx
+VSJdLCJ4dSI6WyJxVSJdLCJiUSI6WyJxVSJdLCJjWCI6WyJxVSJdLCJsZi5FIjoicVUifSwiUk8iOnsi
+cWgiOlsiMSJdfSwiZXUiOnsiUk8iOlsiMSJdLCJxaCI6WyIxIl19LCJ4QyI6eyJNTyI6WyIxIl19LCJ2
+RCI6eyJrRiI6W119LCJtNiI6eyJrRiI6W119LCJjdCI6eyJrRiI6W119LCJPdyI6eyJrRiI6W119LCJX
+OSI6eyJBbiI6WyIxIl19LCJkVyI6eyJ2NiI6W10sIkQwIjpbXX0sIm1rIjp7InkwIjpbXX0sIktvIjp7
+Im9uIjpbXX0sIkFzIjp7ImxmIjpbInFVIl0sInh1IjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFV
+Il19LCJyNyI6eyJFNCI6W119LCJUeiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJF
+NCI6W10sImNYIjpbIjEiXSwibEQuRSI6IjEifSwibmQiOnsiaGkiOltdLCJjdiI6W10sInVIIjpbXSwi
+RDAiOltdfSwiS2UiOnsibGYiOlsicVUiXSwieHUiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUi
+XSwibGYuRSI6InFVIn0sImhpIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJRVyI6eyJYUyI6W10s
+IlJ6IjpbXX0sIlhBIjp7ImtGIjpbXX0sInZ0Ijp7IkQ4IjpbXX0sImNEIjp7IkQ4IjpbXX0sImR2Ijp7
+IlJ6IjpbXX0sIk9GIjp7ImZ2IjpbXX0sInJ1Ijp7ImZ2IjpbXX0sIklWIjp7ImZ2IjpbXX0sIm42Ijp7
+InpNIjpbIklqIl0sImJRIjpbIklqIl0sImNYIjpbIklqIl0sIkFTIjpbXX19JykpCkguRkYodi50eXBl
+VW5pdmVyc2UsSlNPTi5wYXJzZSgneyJ3MiI6MSwiUUMiOjIsIkxaIjoxLCJrVCI6MiwibVciOjEsInV5
+IjoxLCJpbCI6MiwiVmoiOjEsIlh2IjoxLCJuWSI6MSwiV1kiOjEsInBSIjoxLCJ2ZyI6MX0nKSkKdmFy
+IHU9e2w6IkNhbm5vdCBleHRyYWN0IGEgZmlsZSBwYXRoIGZyb20gYSBVUkkgd2l0aCBhIGZyYWdtZW50
+IGNvbXBvbmVudCIsaToiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBhIFVSSSB3aXRoIGEg
+cXVlcnkgY29tcG9uZW50IixqOiJDYW5ub3QgZXh0cmFjdCBhIG5vbi1XaW5kb3dzIGZpbGUgcGF0aCBm
+cm9tIGEgZmlsZSBVUkkgd2l0aCBhbiBhdXRob3JpdHkiLGc6ImBudWxsYCBlbmNvdW50ZXJlZCBhcyB0
+aGUgcmVzdWx0IGZyb20gZXhwcmVzc2lvbiB3aXRoIHR5cGUgYE5ldmVyYC4iLGQ6ImFyZWEtYW5hbHl6
+ZXIsYW5hbHl6ZXItbm5iZC1taWdyYXRpb24sdHlwZS1idWcifQp2YXIgdD0oZnVuY3Rpb24gcnRpaSgp
+e3ZhciBzPUguTjAKcmV0dXJue246cygiQ3ciKSxjUjpzKCJyWiIpLHc6cygiQXoiKSxwOnMoIlFQIiks
+Z0Y6cygiUEQ8R0QsQD4iKSxkOnMoImJRPEA+IiksaDpzKCJjdiIpLHI6cygiWFMiKSxCOnMoImVhIiks
+YVM6cygiRDAiKSxnODpzKCJSeiIpLGM4OnMoImhIIiksWTpzKCJFSCIpLGU6cygiYjg8QD4iKSxJOnMo
+IlNnIiksbzpzKCJ2USIpLGVoOnMoImNYPHVIPiIpLFE6cygiY1g8cVU+IiksdTpzKCJjWDxAPiIpLHY6
+cygiamQ8a0Y+IiksczpzKCJqZDxxVT4iKSxnTjpzKCJqZDxuNj4iKSxiOnMoImpkPEA+IiksYTpzKCJq
+ZDxJaj4iKSxkNzpzKCJqZDxTZSo+IiksaDQ6cygiamQ8ajgqPiIpLEc6cygiamQ8WjA8cVUqLE1oKj4q
+PiIpLGNROnMoImpkPEQ4Kj4iKSxpOnMoImpkPHFVKj4iKSxhQTpzKCJqZDx5RCo+IiksYUo6cygiamQ8
+d2IqPiIpLFY6cygiamQ8SWoqPiIpLGQ0OnMoImpkPHFVPz4iKSxUOnMoIndlIiksZUg6cygidm0iKSx4
+OnMoImM1IiksYVU6cygiWGo8QD4iKSxhbTpzKCJUejxAPiIpLGVvOnMoIk41PEdELEA+IiksZHo6cygi
+aEYiKSxEOnMoInpNPHFVPiIpLGo6cygiek08QD4iKSxMOnMoInpNPElqPiIpLEo6cygiWjA8cVUscVU+
+IiksZjpzKCJaMDxALEA+IiksZG86cygibEo8cVUsQD4iKSxmajpzKCJsSjxxVSoscVU+IiksZlA6cygi
+bEo8cVUqLHFVKj4iKSxkRTpzKCJFVCIpLGJtOnMoIlY2IiksQTpzKCJ1SCIpLEU6cygia0YiKSxQOnMo
+ImM4IiksSzpzKCJNaCIpLHE6cygidG48Wlo+IiksZnY6cygid0wiKSxldzpzKCJuZCIpLEM6cygieHU8
+cVU+IiksbDpzKCJHeiIpLE46cygicVUiKSxkMDpzKCJxVShxVSopIiksZzc6cygiaGkiKSxmbzpzKCJH
+RCIpLGFXOnMoInlZIiksYWs6cygiQVMiKSxnYzpzKCJuNiIpLGJKOnMoImtkIiksZHc6cygiR2o8cVUs
+cVU+IiksZEQ6cygiaUQiKSxlSjpzKCJ1NjxxVT4iKSxnNDpzKCJLNSIpLGNpOnMoInY2IiksZzI6cygi
+Q20iKSxiQzpzKCJaZjxmSio+IiksaDk6cygiQ1EiKSxhYzpzKCJlNyIpLGs6cygiZXU8QWoqPiIpLFI6
+cygid3o8Y3YqPiIpLGM6cygidnM8QD4iKSxmSjpzKCJ2czxJaj4iKSxnVjpzKCJ2czxmSio+IiksY3I6
+cygiSlEiKSx5OnMoImEyIiksYWw6cygiYTIoTWgpIiksZ1I6cygiQ1AiKSx6OnMoIkAiKSxmTzpzKCJA
+KCkiKSxiSTpzKCJAKE1oKSIpLGFnOnMoIkAoTWgsR3opIiksYlU6cygiQCh4dTxxVT4pIiksZE86cygi
+QChxVSkiKSxiODpzKCJAKEAsQCkiKSxTOnMoIklqIiksZGQ6cygiR2gqIiksZzpzKCJjdioiKSxhTDpz
+KCJlYSoiKSxhWDpzKCJMTCoiKSxmRTpzKCJINyoiKSxVOnMoImNYPEA+KiIpLGRIOnMoIkU0KiIpLGZL
+OnMoInpNPEA+KiIpLGRfOnMoInpNPGo4Kj4qIiksZHA6cygiek08WjA8cVUqLE1oKj4qPioiKSxlRTpz
+KCJ6TTxNaCo+KiIpLGF3OnMoIlowPEAsQD4qIiksdDpzKCJaMDxxVSosTWgqPioiKSxPOnMoIkFqKiIp
+LGNGOnMoIjAmKiIpLF86cygiTWgqIiksZVE6cygiZXcqIiksWDpzKCJxVSoiKSxlcTpzKCJxVSoocVUq
+KSIpLGNoOnMoIkQwPyIpLGJHOnMoImI4PGM4Pj8iKSxiazpzKCJ6TTxxVT4/IiksYk06cygiek08QD4/
+IiksY1o6cygiWjA8cVUscVU+PyIpLGM5OnMoIlowPHFVLEA+PyIpLFc6cygiTWg/IiksRjpzKCJGZTxA
+LEA+PyIpLG06cygiYm4/IiksYjc6cygiYTIoTWgpPyIpLGJ3OnMoIkAoZWEpPyIpLGZWOnMoIk1oPyhN
+aD8sTWg/KT8iKSxkQTpzKCJNaD8oQCk/IiksWjpzKCJ+KCk/IiksZWI6cygifihldyopPyIpLGRpOnMo
+IlpaIiksSDpzKCJ+IiksTTpzKCJ+KCkiKSxlQTpzKCJ+KHFVLHFVKSIpLGNBOnMoIn4ocVUsQCkiKX19
+KSgpOyhmdW5jdGlvbiBjb25zdGFudHMoKXt2YXIgcz1odW5rSGVscGVycy5tYWtlQ29uc3RMaXN0CkMu
+eG49Vy5HaC5wcm90b3R5cGUKQy5SWT1XLlFQLnByb3RvdHlwZQpDLm1IPVcuYWUucHJvdG90eXBlCkMu
+Qlo9Vy5WYi5wcm90b3R5cGUKQy5EdD1XLmZKLnByb3RvdHlwZQpDLk9rPUouR3YucHJvdG90eXBlCkMu
+Tm09Si5qZC5wcm90b3R5cGUKQy5qbj1KLmJVLnByb3RvdHlwZQpDLkNEPUoucUkucHJvdG90eXBlCkMu
+eEI9Si5Eci5wcm90b3R5cGUKQy5ERz1KLmM1LnByb3RvdHlwZQpDLkV4PVcudzcucHJvdG90eXBlCkMu
+TkE9SC5WNi5wcm90b3R5cGUKQy50NT1XLkJILnByb3RvdHlwZQpDLkx0PVcuU04ucHJvdG90eXBlCkMu
+WlE9Si5pQy5wcm90b3R5cGUKQy5JZT1XLlRiLnByb3RvdHlwZQpDLnZCPUoua2QucHJvdG90eXBlCkMu
+b2w9Vy5LNS5wcm90b3R5cGUKQy55OD1uZXcgUC5VOCgpCkMuaDk9bmV3IFAuQ1YoKQpDLkd3PW5ldyBI
+LkZ1KEguTjAoIkZ1PDAmKj4iKSkKQy5PND1mdW5jdGlvbiBnZXRUYWdGYWxsYmFjayhvKSB7CiAgdmFy
+IHMgPSBPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nLmNhbGwobyk7CiAgcmV0dXJuIHMuc3Vic3RyaW5n
+KDgsIHMubGVuZ3RoIC0gMSk7Cn0KQy5ZcT1mdW5jdGlvbigpIHsKICB2YXIgdG9TdHJpbmdGdW5jdGlv
+biA9IE9iamVjdC5wcm90b3R5cGUudG9TdHJpbmc7CiAgZnVuY3Rpb24gZ2V0VGFnKG8pIHsKICAgIHZh
+ciBzID0gdG9TdHJpbmdGdW5jdGlvbi5jYWxsKG8pOwogICAgcmV0dXJuIHMuc3Vic3RyaW5nKDgsIHMu
+bGVuZ3RoIC0gMSk7CiAgfQogIGZ1bmN0aW9uIGdldFVua25vd25UYWcob2JqZWN0LCB0YWcpIHsKICAg
+IGlmICgvXkhUTUxbQS1aXS4qRWxlbWVudCQvLnRlc3QodGFnKSkgewogICAgICB2YXIgbmFtZSA9IHRv
+U3RyaW5nRnVuY3Rpb24uY2FsbChvYmplY3QpOwogICAgICBpZiAobmFtZSA9PSAiW29iamVjdCBPYmpl
+Y3RdIikgcmV0dXJuIG51bGw7CiAgICAgIHJldHVybiAiSFRNTEVsZW1lbnQiOwogICAgfQogIH0KICBm
+dW5jdGlvbiBnZXRVbmtub3duVGFnR2VuZXJpY0Jyb3dzZXIob2JqZWN0LCB0YWcpIHsKICAgIGlmIChz
+ZWxmLkhUTUxFbGVtZW50ICYmIG9iamVjdCBpbnN0YW5jZW9mIEhUTUxFbGVtZW50KSByZXR1cm4gIkhU
+TUxFbGVtZW50IjsKICAgIHJldHVybiBnZXRVbmtub3duVGFnKG9iamVjdCwgdGFnKTsKICB9CiAgZnVu
+Y3Rpb24gcHJvdG90eXBlRm9yVGFnKHRhZykgewogICAgaWYgKHR5cGVvZiB3aW5kb3cgPT0gInVuZGVm
+aW5lZCIpIHJldHVybiBudWxsOwogICAgaWYgKHR5cGVvZiB3aW5kb3dbdGFnXSA9PSAidW5kZWZpbmVk
+IikgcmV0dXJuIG51bGw7CiAgICB2YXIgY29uc3RydWN0b3IgPSB3aW5kb3dbdGFnXTsKICAgIGlmICh0
+eXBlb2YgY29uc3RydWN0b3IgIT0gImZ1bmN0aW9uIikgcmV0dXJuIG51bGw7CiAgICByZXR1cm4gY29u
+c3RydWN0b3IucHJvdG90eXBlOwogIH0KICBmdW5jdGlvbiBkaXNjcmltaW5hdG9yKHRhZykgeyByZXR1
+cm4gbnVsbDsgfQogIHZhciBpc0Jyb3dzZXIgPSB0eXBlb2YgbmF2aWdhdG9yID09ICJvYmplY3QiOwog
+IHJldHVybiB7CiAgICBnZXRUYWc6IGdldFRhZywKICAgIGdldFVua25vd25UYWc6IGlzQnJvd3NlciA/
+IGdldFVua25vd25UYWdHZW5lcmljQnJvd3NlciA6IGdldFVua25vd25UYWcsCiAgICBwcm90b3R5cGVG
+b3JUYWc6IHByb3RvdHlwZUZvclRhZywKICAgIGRpc2NyaW1pbmF0b3I6IGRpc2NyaW1pbmF0b3IgfTsK
+fQpDLndiPWZ1bmN0aW9uKGdldFRhZ0ZhbGxiYWNrKSB7CiAgcmV0dXJuIGZ1bmN0aW9uKGhvb2tzKSB7
+CiAgICBpZiAodHlwZW9mIG5hdmlnYXRvciAhPSAib2JqZWN0IikgcmV0dXJuIGhvb2tzOwogICAgdmFy
+IHVhID0gbmF2aWdhdG9yLnVzZXJBZ2VudDsKICAgIGlmICh1YS5pbmRleE9mKCJEdW1wUmVuZGVyVHJl
+ZSIpID49IDApIHJldHVybiBob29rczsKICAgIGlmICh1YS5pbmRleE9mKCJDaHJvbWUiKSA+PSAwKSB7
+CiAgICAgIGZ1bmN0aW9uIGNvbmZpcm0ocCkgewogICAgICAgIHJldHVybiB0eXBlb2Ygd2luZG93ID09
+ICJvYmplY3QiICYmIHdpbmRvd1twXSAmJiB3aW5kb3dbcF0ubmFtZSA9PSBwOwogICAgICB9CiAgICAg
+IGlmIChjb25maXJtKCJXaW5kb3ciKSAmJiBjb25maXJtKCJIVE1MRWxlbWVudCIpKSByZXR1cm4gaG9v
+a3M7CiAgICB9CiAgICBob29rcy5nZXRUYWcgPSBnZXRUYWdGYWxsYmFjazsKICB9Owp9CkMuS1U9ZnVu
+Y3Rpb24oaG9va3MpIHsKICBpZiAodHlwZW9mIGRhcnRFeHBlcmltZW50YWxGaXh1cEdldFRhZyAhPSAi
+ZnVuY3Rpb24iKSByZXR1cm4gaG9va3M7CiAgaG9va3MuZ2V0VGFnID0gZGFydEV4cGVyaW1lbnRhbEZp
+eHVwR2V0VGFnKGhvb2tzLmdldFRhZyk7Cn0KQy5mUT1mdW5jdGlvbihob29rcykgewogIHZhciBnZXRU
+YWcgPSBob29rcy5nZXRUYWc7CiAgdmFyIHByb3RvdHlwZUZvclRhZyA9IGhvb2tzLnByb3RvdHlwZUZv
+clRhZzsKICBmdW5jdGlvbiBnZXRUYWdGaXhlZChvKSB7CiAgICB2YXIgdGFnID0gZ2V0VGFnKG8pOwog
+ICAgaWYgKHRhZyA9PSAiRG9jdW1lbnQiKSB7CiAgICAgIGlmICghIW8ueG1sVmVyc2lvbikgcmV0dXJu
+ICIhRG9jdW1lbnQiOwogICAgICByZXR1cm4gIiFIVE1MRG9jdW1lbnQiOwogICAgfQogICAgcmV0dXJu
+IHRhZzsKICB9CiAgZnVuY3Rpb24gcHJvdG90eXBlRm9yVGFnRml4ZWQodGFnKSB7CiAgICBpZiAodGFn
+ID09ICJEb2N1bWVudCIpIHJldHVybiBudWxsOwogICAgcmV0dXJuIHByb3RvdHlwZUZvclRhZyh0YWcp
+OwogIH0KICBob29rcy5nZXRUYWcgPSBnZXRUYWdGaXhlZDsKICBob29rcy5wcm90b3R5cGVGb3JUYWcg
+PSBwcm90b3R5cGVGb3JUYWdGaXhlZDsKfQpDLmRrPWZ1bmN0aW9uKGhvb2tzKSB7CiAgdmFyIHVzZXJB
+Z2VudCA9IHR5cGVvZiBuYXZpZ2F0b3IgPT0gIm9iamVjdCIgPyBuYXZpZ2F0b3IudXNlckFnZW50IDog
+IiI7CiAgaWYgKHVzZXJBZ2VudC5pbmRleE9mKCJGaXJlZm94IikgPT0gLTEpIHJldHVybiBob29rczsK
+ICB2YXIgZ2V0VGFnID0gaG9va3MuZ2V0VGFnOwogIHZhciBxdWlja01hcCA9IHsKICAgICJCZWZvcmVV
+bmxvYWRFdmVudCI6ICJFdmVudCIsCiAgICAiRGF0YVRyYW5zZmVyIjogIkNsaXBib2FyZCIsCiAgICAi
+R2VvR2VvbG9jYXRpb24iOiAiR2VvbG9jYXRpb24iLAogICAgIkxvY2F0aW9uIjogIiFMb2NhdGlvbiIs
+CiAgICAiV29ya2VyTWVzc2FnZUV2ZW50IjogIk1lc3NhZ2VFdmVudCIsCiAgICAiWE1MRG9jdW1lbnQi
+OiAiIURvY3VtZW50In07CiAgZnVuY3Rpb24gZ2V0VGFnRmlyZWZveChvKSB7CiAgICB2YXIgdGFnID0g
+Z2V0VGFnKG8pOwogICAgcmV0dXJuIHF1aWNrTWFwW3RhZ10gfHwgdGFnOwogIH0KICBob29rcy5nZXRU
+YWcgPSBnZXRUYWdGaXJlZm94Owp9CkMueGk9ZnVuY3Rpb24oaG9va3MpIHsKICB2YXIgdXNlckFnZW50
+ID0gdHlwZW9mIG5hdmlnYXRvciA9PSAib2JqZWN0IiA/IG5hdmlnYXRvci51c2VyQWdlbnQgOiAiIjsK
+ICBpZiAodXNlckFnZW50LmluZGV4T2YoIlRyaWRlbnQvIikgPT0gLTEpIHJldHVybiBob29rczsKICB2
+YXIgZ2V0VGFnID0gaG9va3MuZ2V0VGFnOwogIHZhciBxdWlja01hcCA9IHsKICAgICJCZWZvcmVVbmxv
+YWRFdmVudCI6ICJFdmVudCIsCiAgICAiRGF0YVRyYW5zZmVyIjogIkNsaXBib2FyZCIsCiAgICAiSFRN
+TERERWxlbWVudCI6ICJIVE1MRWxlbWVudCIsCiAgICAiSFRNTERURWxlbWVudCI6ICJIVE1MRWxlbWVu
+dCIsCiAgICAiSFRNTFBocmFzZUVsZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIlBvc2l0aW9uIjog
+Ikdlb3Bvc2l0aW9uIgogIH07CiAgZnVuY3Rpb24gZ2V0VGFnSUUobykgewogICAgdmFyIHRhZyA9IGdl
+dFRhZyhvKTsKICAgIHZhciBuZXdUYWcgPSBxdWlja01hcFt0YWddOwogICAgaWYgKG5ld1RhZykgcmV0
+dXJuIG5ld1RhZzsKICAgIGlmICh0YWcgPT0gIk9iamVjdCIpIHsKICAgICAgaWYgKHdpbmRvdy5EYXRh
+VmlldyAmJiAobyBpbnN0YW5jZW9mIHdpbmRvdy5EYXRhVmlldykpIHJldHVybiAiRGF0YVZpZXciOwog
+ICAgfQogICAgcmV0dXJuIHRhZzsKICB9CiAgZnVuY3Rpb24gcHJvdG90eXBlRm9yVGFnSUUodGFnKSB7
+CiAgICB2YXIgY29uc3RydWN0b3IgPSB3aW5kb3dbdGFnXTsKICAgIGlmIChjb25zdHJ1Y3RvciA9PSBu
+dWxsKSByZXR1cm4gbnVsbDsKICAgIHJldHVybiBjb25zdHJ1Y3Rvci5wcm90b3R5cGU7CiAgfQogIGhv
+b2tzLmdldFRhZyA9IGdldFRhZ0lFOwogIGhvb2tzLnByb3RvdHlwZUZvclRhZyA9IHByb3RvdHlwZUZv
+clRhZ0lFOwp9CkMuaTc9ZnVuY3Rpb24oaG9va3MpIHsgcmV0dXJuIGhvb2tzOyB9CgpDLkN0PW5ldyBQ
+LmJ5KCkKQy5FcT1uZXcgUC5rNSgpCkMueE09bmV3IFAudTUoKQpDLlFrPW5ldyBQLkUzKCkKQy5Odj1u
+ZXcgSC5rcigpCkMuTlU9bmV3IFAuSmkoKQpDLnBkPW5ldyBQLlpkKCkKQy5BZD1uZXcgUi5INygwLCJI
+aW50QWN0aW9uS2luZC5hZGROdWxsYWJsZUhpbnQiKQpDLm5lPW5ldyBSLkg3KDEsIkhpbnRBY3Rpb25L
+aW5kLmFkZE5vbk51bGxhYmxlSGludCIpCkMubXk9bmV3IFIuSDcoMiwiSGludEFjdGlvbktpbmQuY2hh
+bmdlVG9OdWxsYWJsZUhpbnQiKQpDLnJ4PW5ldyBSLkg3KDMsIkhpbnRBY3Rpb25LaW5kLmNoYW5nZVRv
+Tm9uTnVsbGFibGVIaW50IikKQy53Vj1uZXcgUi5INyg0LCJIaW50QWN0aW9uS2luZC5yZW1vdmVOdWxs
+YWJsZUhpbnQiKQpDLmZSPW5ldyBSLkg3KDUsIkhpbnRBY3Rpb25LaW5kLnJlbW92ZU5vbk51bGxhYmxl
+SGludCIpCkMuQTM9bmV3IFAuTXgobnVsbCkKQy5uWD1uZXcgUC5vaihudWxsKQpDLmN3PW5ldyBMLkdi
+KDAsIlVuaXRNaWdyYXRpb25TdGF0dXMuYWxyZWFkeU1pZ3JhdGVkIikKQy5kYz1uZXcgTC5HYigxLCJV
+bml0TWlncmF0aW9uU3RhdHVzLmluZGV0ZXJtaW5hdGUiKQpDLldEPW5ldyBMLkdiKDIsIlVuaXRNaWdy
+YXRpb25TdGF0dXMubWlncmF0aW5nIikKQy5Yaj1uZXcgTC5HYigzLCJVbml0TWlncmF0aW9uU3RhdHVz
+Lm9wdGluZ091dCIpCkMubDA9SC5RSShzKFtDLmN3LEMuZGMsQy5XRCxDLlhqXSksSC5OMCgiamQ8R2Iq
+PiIpKQpDLmFrPUguUUkocyhbMCwwLDMyNzc2LDMzNzkyLDEsMTAyNDAsMCwwXSksdC5WKQpDLmNtPUgu
+UUkocyhbIio6OmNsYXNzIiwiKjo6ZGlyIiwiKjo6ZHJhZ2dhYmxlIiwiKjo6aGlkZGVuIiwiKjo6aWQi
+LCIqOjppbmVydCIsIio6Oml0ZW1wcm9wIiwiKjo6aXRlbXJlZiIsIio6Oml0ZW1zY29wZSIsIio6Omxh
+bmciLCIqOjpzcGVsbGNoZWNrIiwiKjo6dGl0bGUiLCIqOjp0cmFuc2xhdGUiLCJBOjphY2Nlc3NrZXki
+LCJBOjpjb29yZHMiLCJBOjpocmVmbGFuZyIsIkE6Om5hbWUiLCJBOjpzaGFwZSIsIkE6OnRhYmluZGV4
+IiwiQTo6dGFyZ2V0IiwiQTo6dHlwZSIsIkFSRUE6OmFjY2Vzc2tleSIsIkFSRUE6OmFsdCIsIkFSRUE6
+OmNvb3JkcyIsIkFSRUE6Om5vaHJlZiIsIkFSRUE6OnNoYXBlIiwiQVJFQTo6dGFiaW5kZXgiLCJBUkVB
+Ojp0YXJnZXQiLCJBVURJTzo6Y29udHJvbHMiLCJBVURJTzo6bG9vcCIsIkFVRElPOjptZWRpYWdyb3Vw
+IiwiQVVESU86Om11dGVkIiwiQVVESU86OnByZWxvYWQiLCJCRE86OmRpciIsIkJPRFk6OmFsaW5rIiwi
+Qk9EWTo6Ymdjb2xvciIsIkJPRFk6OmxpbmsiLCJCT0RZOjp0ZXh0IiwiQk9EWTo6dmxpbmsiLCJCUjo6
+Y2xlYXIiLCJCVVRUT046OmFjY2Vzc2tleSIsIkJVVFRPTjo6ZGlzYWJsZWQiLCJCVVRUT046Om5hbWUi
+LCJCVVRUT046OnRhYmluZGV4IiwiQlVUVE9OOjp0eXBlIiwiQlVUVE9OOjp2YWx1ZSIsIkNBTlZBUzo6
+aGVpZ2h0IiwiQ0FOVkFTOjp3aWR0aCIsIkNBUFRJT046OmFsaWduIiwiQ09MOjphbGlnbiIsIkNPTDo6
+Y2hhciIsIkNPTDo6Y2hhcm9mZiIsIkNPTDo6c3BhbiIsIkNPTDo6dmFsaWduIiwiQ09MOjp3aWR0aCIs
+IkNPTEdST1VQOjphbGlnbiIsIkNPTEdST1VQOjpjaGFyIiwiQ09MR1JPVVA6OmNoYXJvZmYiLCJDT0xH
+Uk9VUDo6c3BhbiIsIkNPTEdST1VQOjp2YWxpZ24iLCJDT0xHUk9VUDo6d2lkdGgiLCJDT01NQU5EOjpj
+aGVja2VkIiwiQ09NTUFORDo6Y29tbWFuZCIsIkNPTU1BTkQ6OmRpc2FibGVkIiwiQ09NTUFORDo6bGFi
+ZWwiLCJDT01NQU5EOjpyYWRpb2dyb3VwIiwiQ09NTUFORDo6dHlwZSIsIkRBVEE6OnZhbHVlIiwiREVM
+OjpkYXRldGltZSIsIkRFVEFJTFM6Om9wZW4iLCJESVI6OmNvbXBhY3QiLCJESVY6OmFsaWduIiwiREw6
+OmNvbXBhY3QiLCJGSUVMRFNFVDo6ZGlzYWJsZWQiLCJGT05UOjpjb2xvciIsIkZPTlQ6OmZhY2UiLCJG
+T05UOjpzaXplIiwiRk9STTo6YWNjZXB0IiwiRk9STTo6YXV0b2NvbXBsZXRlIiwiRk9STTo6ZW5jdHlw
+ZSIsIkZPUk06Om1ldGhvZCIsIkZPUk06Om5hbWUiLCJGT1JNOjpub3ZhbGlkYXRlIiwiRk9STTo6dGFy
+Z2V0IiwiRlJBTUU6Om5hbWUiLCJIMTo6YWxpZ24iLCJIMjo6YWxpZ24iLCJIMzo6YWxpZ24iLCJINDo6
+YWxpZ24iLCJINTo6YWxpZ24iLCJINjo6YWxpZ24iLCJIUjo6YWxpZ24iLCJIUjo6bm9zaGFkZSIsIkhS
+OjpzaXplIiwiSFI6OndpZHRoIiwiSFRNTDo6dmVyc2lvbiIsIklGUkFNRTo6YWxpZ24iLCJJRlJBTUU6
+OmZyYW1lYm9yZGVyIiwiSUZSQU1FOjpoZWlnaHQiLCJJRlJBTUU6Om1hcmdpbmhlaWdodCIsIklGUkFN
+RTo6bWFyZ2lud2lkdGgiLCJJRlJBTUU6OndpZHRoIiwiSU1HOjphbGlnbiIsIklNRzo6YWx0IiwiSU1H
+Ojpib3JkZXIiLCJJTUc6OmhlaWdodCIsIklNRzo6aHNwYWNlIiwiSU1HOjppc21hcCIsIklNRzo6bmFt
+ZSIsIklNRzo6dXNlbWFwIiwiSU1HOjp2c3BhY2UiLCJJTUc6OndpZHRoIiwiSU5QVVQ6OmFjY2VwdCIs
+IklOUFVUOjphY2Nlc3NrZXkiLCJJTlBVVDo6YWxpZ24iLCJJTlBVVDo6YWx0IiwiSU5QVVQ6OmF1dG9j
+b21wbGV0ZSIsIklOUFVUOjphdXRvZm9jdXMiLCJJTlBVVDo6Y2hlY2tlZCIsIklOUFVUOjpkaXNhYmxl
+ZCIsIklOUFVUOjppbnB1dG1vZGUiLCJJTlBVVDo6aXNtYXAiLCJJTlBVVDo6bGlzdCIsIklOUFVUOjpt
+YXgiLCJJTlBVVDo6bWF4bGVuZ3RoIiwiSU5QVVQ6Om1pbiIsIklOUFVUOjptdWx0aXBsZSIsIklOUFVU
+OjpuYW1lIiwiSU5QVVQ6OnBsYWNlaG9sZGVyIiwiSU5QVVQ6OnJlYWRvbmx5IiwiSU5QVVQ6OnJlcXVp
+cmVkIiwiSU5QVVQ6OnNpemUiLCJJTlBVVDo6c3RlcCIsIklOUFVUOjp0YWJpbmRleCIsIklOUFVUOjp0
+eXBlIiwiSU5QVVQ6OnVzZW1hcCIsIklOUFVUOjp2YWx1ZSIsIklOUzo6ZGF0ZXRpbWUiLCJLRVlHRU46
+OmRpc2FibGVkIiwiS0VZR0VOOjprZXl0eXBlIiwiS0VZR0VOOjpuYW1lIiwiTEFCRUw6OmFjY2Vzc2tl
+eSIsIkxBQkVMOjpmb3IiLCJMRUdFTkQ6OmFjY2Vzc2tleSIsIkxFR0VORDo6YWxpZ24iLCJMSTo6dHlw
+ZSIsIkxJOjp2YWx1ZSIsIkxJTks6OnNpemVzIiwiTUFQOjpuYW1lIiwiTUVOVTo6Y29tcGFjdCIsIk1F
+TlU6OmxhYmVsIiwiTUVOVTo6dHlwZSIsIk1FVEVSOjpoaWdoIiwiTUVURVI6OmxvdyIsIk1FVEVSOjpt
+YXgiLCJNRVRFUjo6bWluIiwiTUVURVI6OnZhbHVlIiwiT0JKRUNUOjp0eXBlbXVzdG1hdGNoIiwiT0w6
+OmNvbXBhY3QiLCJPTDo6cmV2ZXJzZWQiLCJPTDo6c3RhcnQiLCJPTDo6dHlwZSIsIk9QVEdST1VQOjpk
+aXNhYmxlZCIsIk9QVEdST1VQOjpsYWJlbCIsIk9QVElPTjo6ZGlzYWJsZWQiLCJPUFRJT046OmxhYmVs
+IiwiT1BUSU9OOjpzZWxlY3RlZCIsIk9QVElPTjo6dmFsdWUiLCJPVVRQVVQ6OmZvciIsIk9VVFBVVDo6
+bmFtZSIsIlA6OmFsaWduIiwiUFJFOjp3aWR0aCIsIlBST0dSRVNTOjptYXgiLCJQUk9HUkVTUzo6bWlu
+IiwiUFJPR1JFU1M6OnZhbHVlIiwiU0VMRUNUOjphdXRvY29tcGxldGUiLCJTRUxFQ1Q6OmRpc2FibGVk
+IiwiU0VMRUNUOjptdWx0aXBsZSIsIlNFTEVDVDo6bmFtZSIsIlNFTEVDVDo6cmVxdWlyZWQiLCJTRUxF
+Q1Q6OnNpemUiLCJTRUxFQ1Q6OnRhYmluZGV4IiwiU09VUkNFOjp0eXBlIiwiVEFCTEU6OmFsaWduIiwi
+VEFCTEU6OmJnY29sb3IiLCJUQUJMRTo6Ym9yZGVyIiwiVEFCTEU6OmNlbGxwYWRkaW5nIiwiVEFCTEU6
+OmNlbGxzcGFjaW5nIiwiVEFCTEU6OmZyYW1lIiwiVEFCTEU6OnJ1bGVzIiwiVEFCTEU6OnN1bW1hcnki
+LCJUQUJMRTo6d2lkdGgiLCJUQk9EWTo6YWxpZ24iLCJUQk9EWTo6Y2hhciIsIlRCT0RZOjpjaGFyb2Zm
+IiwiVEJPRFk6OnZhbGlnbiIsIlREOjphYmJyIiwiVEQ6OmFsaWduIiwiVEQ6OmF4aXMiLCJURDo6Ymdj
+b2xvciIsIlREOjpjaGFyIiwiVEQ6OmNoYXJvZmYiLCJURDo6Y29sc3BhbiIsIlREOjpoZWFkZXJzIiwi
+VEQ6OmhlaWdodCIsIlREOjpub3dyYXAiLCJURDo6cm93c3BhbiIsIlREOjpzY29wZSIsIlREOjp2YWxp
+Z24iLCJURDo6d2lkdGgiLCJURVhUQVJFQTo6YWNjZXNza2V5IiwiVEVYVEFSRUE6OmF1dG9jb21wbGV0
+ZSIsIlRFWFRBUkVBOjpjb2xzIiwiVEVYVEFSRUE6OmRpc2FibGVkIiwiVEVYVEFSRUE6OmlucHV0bW9k
+ZSIsIlRFWFRBUkVBOjpuYW1lIiwiVEVYVEFSRUE6OnBsYWNlaG9sZGVyIiwiVEVYVEFSRUE6OnJlYWRv
+bmx5IiwiVEVYVEFSRUE6OnJlcXVpcmVkIiwiVEVYVEFSRUE6OnJvd3MiLCJURVhUQVJFQTo6dGFiaW5k
+ZXgiLCJURVhUQVJFQTo6d3JhcCIsIlRGT09UOjphbGlnbiIsIlRGT09UOjpjaGFyIiwiVEZPT1Q6OmNo
+YXJvZmYiLCJURk9PVDo6dmFsaWduIiwiVEg6OmFiYnIiLCJUSDo6YWxpZ24iLCJUSDo6YXhpcyIsIlRI
+OjpiZ2NvbG9yIiwiVEg6OmNoYXIiLCJUSDo6Y2hhcm9mZiIsIlRIOjpjb2xzcGFuIiwiVEg6OmhlYWRl
+cnMiLCJUSDo6aGVpZ2h0IiwiVEg6Om5vd3JhcCIsIlRIOjpyb3dzcGFuIiwiVEg6OnNjb3BlIiwiVEg6
+OnZhbGlnbiIsIlRIOjp3aWR0aCIsIlRIRUFEOjphbGlnbiIsIlRIRUFEOjpjaGFyIiwiVEhFQUQ6OmNo
+YXJvZmYiLCJUSEVBRDo6dmFsaWduIiwiVFI6OmFsaWduIiwiVFI6OmJnY29sb3IiLCJUUjo6Y2hhciIs
+IlRSOjpjaGFyb2ZmIiwiVFI6OnZhbGlnbiIsIlRSQUNLOjpkZWZhdWx0IiwiVFJBQ0s6OmtpbmQiLCJU
+UkFDSzo6bGFiZWwiLCJUUkFDSzo6c3JjbGFuZyIsIlVMOjpjb21wYWN0IiwiVUw6OnR5cGUiLCJWSURF
+Tzo6Y29udHJvbHMiLCJWSURFTzo6aGVpZ2h0IiwiVklERU86Omxvb3AiLCJWSURFTzo6bWVkaWFncm91
+cCIsIlZJREVPOjptdXRlZCIsIlZJREVPOjpwcmVsb2FkIiwiVklERU86OndpZHRoIl0pLHQuaSkKQy5W
+Qz1ILlFJKHMoWzAsMCw2NTQ5MCw0NTA1NSw2NTUzNSwzNDgxNSw2NTUzNCwxODQzMV0pLHQuVikKQy5t
+Sz1ILlFJKHMoWzAsMCwyNjYyNCwxMDIzLDY1NTM0LDIwNDcsNjU1MzQsMjA0N10pLHQuVikKQy5TcT1I
+LlFJKHMoWyJIRUFEIiwiQVJFQSIsIkJBU0UiLCJCQVNFRk9OVCIsIkJSIiwiQ09MIiwiQ09MR1JPVVAi
+LCJFTUJFRCIsIkZSQU1FIiwiRlJBTUVTRVQiLCJIUiIsIklNQUdFIiwiSU1HIiwiSU5QVVQiLCJJU0lO
+REVYIiwiTElOSyIsIk1FVEEiLCJQQVJBTSIsIlNPVVJDRSIsIlNUWUxFIiwiVElUTEUiLCJXQlIiXSks
+dC5pKQpDLmhVPUguUUkocyhbXSksdC5iKQpDLmRuPUguUUkocyhbXSksSC5OMCgiamQ8TEwqPiIpKQpD
+LnhEPUguUUkocyhbXSksdC5pKQpDLnRvPUguUUkocyhbMCwwLDMyNzIyLDEyMjg3LDY1NTM0LDM0ODE1
+LDY1NTM0LDE4NDMxXSksdC5WKQpDLnJrPUguUUkocyhbQy5BZCxDLm5lLEMubXksQy5yeCxDLndWLEMu
+ZlJdKSxILk4wKCJqZDxINyo+IikpCkMuRjM9SC5RSShzKFswLDAsMjQ1NzYsMTAyMyw2NTUzNCwzNDgx
+NSw2NTUzNCwxODQzMV0pLHQuVikKQy5lYT1ILlFJKHMoWzAsMCwzMjc1NCwxMTI2Myw2NTUzNCwzNDgx
+NSw2NTUzNCwxODQzMV0pLHQuVikKQy5aSj1ILlFJKHMoWzAsMCwzMjcyMiwxMjI4Nyw2NTUzNSwzNDgx
+NSw2NTUzNCwxODQzMV0pLHQuVikKQy5XZD1ILlFJKHMoWzAsMCw2NTQ5MCwxMjI4Nyw2NTUzNSwzNDgx
+NSw2NTUzNCwxODQzMV0pLHQuVikKQy5ReD1ILlFJKHMoWyJiaW5kIiwiaWYiLCJyZWYiLCJyZXBlYXQi
+LCJzeW50YXgiXSksdC5pKQpDLkJJPUguUUkocyhbIkE6OmhyZWYiLCJBUkVBOjpocmVmIiwiQkxPQ0tR
+VU9URTo6Y2l0ZSIsIkJPRFk6OmJhY2tncm91bmQiLCJDT01NQU5EOjppY29uIiwiREVMOjpjaXRlIiwi
+Rk9STTo6YWN0aW9uIiwiSU1HOjpzcmMiLCJJTlBVVDo6c3JjIiwiSU5TOjpjaXRlIiwiUTo6Y2l0ZSIs
+IlZJREVPOjpwb3N0ZXIiXSksdC5pKQpDLkR4PW5ldyBILkxQKDAse30sQy54RCxILk4wKCJMUDxxVSos
+ek08ajgqPio+IikpCkMuQ009bmV3IEguTFAoMCx7fSxDLnhELEguTjAoIkxQPHFVKixxVSo+IikpCkMu
+aUg9SC5RSShzKFtdKSxILk4wKCJqZDxHRCo+IikpCkMuV089bmV3IEguTFAoMCx7fSxDLmlILEguTjAo
+IkxQPEdEKixAPiIpKQpDLlkyPW5ldyBMLk85KCJOYXZpZ2F0aW9uVHJlZU5vZGVUeXBlLmRpcmVjdG9y
+eSIpCkMucmY9bmV3IEwuTzkoIk5hdmlnYXRpb25UcmVlTm9kZVR5cGUuZmlsZSIpCkMuVGU9bmV3IEgu
+d3YoImNhbGwiKQpDLm9FPW5ldyBQLkdZKCExKQpDLndRPW5ldyBQLkZ5KG51bGwsMil9KSgpOyhmdW5j
+dGlvbiBzdGF0aWNGaWVsZHMoKXskLnptPW51bGwKJC55aj0wCiQuV1c9bnVsbAokLmkwPW51bGwKJC5O
+Rj1udWxsCiQuVFg9bnVsbAokLng3PW51bGwKJC5udz1udWxsCiQudnY9bnVsbAokLkJ2PW51bGwKJC5T
+Nj1udWxsCiQuazg9bnVsbAokLm1nPW51bGwKJC5VRD0hMQokLlgzPUMuTlUKJC5GPUguUUkoW10sSC5O
+MCgiamQ8TWg+IikpCiQueG89bnVsbAokLkJPPW51bGwKJC5sdD1udWxsCiQuRVU9bnVsbAokLm9yPVAu
+RmwodC5OLHQuWSkKJC5JUj1udWxsCiQuSTY9bnVsbAokLkZmPW51bGx9KSgpOyhmdW5jdGlvbiBsYXp5
+SW5pdGlhbGl6ZXJzKCl7dmFyIHM9aHVua0hlbHBlcnMubGF6eUZpbmFsLHI9aHVua0hlbHBlcnMubGF6
+eU9sZApzKCQsImZhIiwieiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5ZZygiXyRkYXJ0X2RhcnRDbG9zdXJl
+Iil9KQpzKCQsIktxIiwiU24iLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5TNyh7CnRvU3RyaW5nOmZ1
+bmN0aW9uKCl7cmV0dXJuIiRyZWNlaXZlciQifX0pKX0pCnMoJCwieHEiLCJscSIsZnVuY3Rpb24oKXty
+ZXR1cm4gSC5jTShILlM3KHskbWV0aG9kJDpudWxsLAp0b1N0cmluZzpmdW5jdGlvbigpe3JldHVybiIk
+cmVjZWl2ZXIkIn19KSl9KQpzKCQsIlIxIiwiTjkiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5TNyhu
+dWxsKSl9KQpzKCQsImZOIiwiaUkiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oZnVuY3Rpb24oKXt2YXIg
+JGFyZ3VtZW50c0V4cHIkPSIkYXJndW1lbnRzJCIKdHJ5e251bGwuJG1ldGhvZCQoJGFyZ3VtZW50c0V4
+cHIkKX1jYXRjaChxKXtyZXR1cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsInFpIiwiVU4iLGZ1bmN0aW9u
+KCl7cmV0dXJuIEguY00oSC5TNyh2b2lkIDApKX0pCnMoJCwicHYiLCJaaCIsZnVuY3Rpb24oKXtyZXR1
+cm4gSC5jTShmdW5jdGlvbigpe3ZhciAkYXJndW1lbnRzRXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7KHZv
+aWQgMCkuJG1ldGhvZCQoJGFyZ3VtZW50c0V4cHIkKX1jYXRjaChxKXtyZXR1cm4gcS5tZXNzYWdlfX0o
+KSl9KQpzKCQsImtxIiwick4iLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5NaihudWxsKSl9KQpzKCQs
+InR0IiwiYzMiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oZnVuY3Rpb24oKXt0cnl7bnVsbC4kbWV0aG9k
+JH1jYXRjaChxKXtyZXR1cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsImR0IiwiSEsiLGZ1bmN0aW9uKCl7
+cmV0dXJuIEguY00oSC5Naih2b2lkIDApKX0pCnMoJCwiQTciLCJyMSIsZnVuY3Rpb24oKXtyZXR1cm4g
+SC5jTShmdW5jdGlvbigpe3RyeXsodm9pZCAwKS4kbWV0aG9kJH1jYXRjaChxKXtyZXR1cm4gcS5tZXNz
+YWdlfX0oKSl9KQpzKCQsIldjIiwidXQiLGZ1bmN0aW9uKCl7cmV0dXJuIFAueGcoKX0pCnMoJCwia2gi
+LCJyZiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFAueHIoKS4kMCgpfSkKcygkLCJkSCIsIkhHIixmdW5j
+dGlvbigpe3JldHVybiBuZXcgUC5OeigpLiQwKCl9KQpzKCQsImhqIiwiVjciLGZ1bmN0aW9uKCl7cmV0
+dXJuIG5ldyBJbnQ4QXJyYXkoSC5YRihILlFJKFstMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwt
+MiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwt
+MiwtMiwtMiwtMiwtMiwtMiwtMiwtMSwtMiwtMiwtMiwtMiwtMiw2MiwtMiw2MiwtMiw2Myw1Miw1Myw1
+NCw1NSw1Niw1Nyw1OCw1OSw2MCw2MSwtMiwtMiwtMiwtMSwtMiwtMiwtMiwwLDEsMiwzLDQsNSw2LDcs
+OCw5LDEwLDExLDEyLDEzLDE0LDE1LDE2LDE3LDE4LDE5LDIwLDIxLDIyLDIzLDI0LDI1LC0yLC0yLC0y
+LC0yLDYzLC0yLDI2LDI3LDI4LDI5LDMwLDMxLDMyLDMzLDM0LDM1LDM2LDM3LDM4LDM5LDQwLDQxLDQy
+LDQzLDQ0LDQ1LDQ2LDQ3LDQ4LDQ5LDUwLDUxLC0yLC0yLC0yLC0yLC0yXSx0LmEpKSl9KQpzKCQsIlll
+Iiwid1EiLGZ1bmN0aW9uKCl7cmV0dXJuIHR5cGVvZiBwcm9jZXNzIT0idW5kZWZpbmVkIiYmT2JqZWN0
+LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKHByb2Nlc3MpPT0iW29iamVjdCBwcm9jZXNzXSImJnByb2Nl
+c3MucGxhdGZvcm09PSJ3aW4zMiJ9KQpzKCQsIm1mIiwiejQiLGZ1bmN0aW9uKCl7cmV0dXJuIFAubnUo
+Il5bXFwtXFwuMC05QS1aX2Eten5dKiQiKX0pCnMoJCwiT1EiLCJ2WiIsZnVuY3Rpb24oKXtyZXR1cm4g
+UC5LTigpfSkKcygkLCJTQyIsIkFOIixmdW5jdGlvbigpe3JldHVybiBQLnRNKFsiQSIsIkFCQlIiLCJB
+Q1JPTllNIiwiQUREUkVTUyIsIkFSRUEiLCJBUlRJQ0xFIiwiQVNJREUiLCJBVURJTyIsIkIiLCJCREki
+LCJCRE8iLCJCSUciLCJCTE9DS1FVT1RFIiwiQlIiLCJCVVRUT04iLCJDQU5WQVMiLCJDQVBUSU9OIiwi
+Q0VOVEVSIiwiQ0lURSIsIkNPREUiLCJDT0wiLCJDT0xHUk9VUCIsIkNPTU1BTkQiLCJEQVRBIiwiREFU
+QUxJU1QiLCJERCIsIkRFTCIsIkRFVEFJTFMiLCJERk4iLCJESVIiLCJESVYiLCJETCIsIkRUIiwiRU0i
+LCJGSUVMRFNFVCIsIkZJR0NBUFRJT04iLCJGSUdVUkUiLCJGT05UIiwiRk9PVEVSIiwiRk9STSIsIkgx
+IiwiSDIiLCJIMyIsIkg0IiwiSDUiLCJINiIsIkhFQURFUiIsIkhHUk9VUCIsIkhSIiwiSSIsIklGUkFN
+RSIsIklNRyIsIklOUFVUIiwiSU5TIiwiS0JEIiwiTEFCRUwiLCJMRUdFTkQiLCJMSSIsIk1BUCIsIk1B
+UksiLCJNRU5VIiwiTUVURVIiLCJOQVYiLCJOT0JSIiwiT0wiLCJPUFRHUk9VUCIsIk9QVElPTiIsIk9V
+VFBVVCIsIlAiLCJQUkUiLCJQUk9HUkVTUyIsIlEiLCJTIiwiU0FNUCIsIlNFQ1RJT04iLCJTRUxFQ1Qi
+LCJTTUFMTCIsIlNPVVJDRSIsIlNQQU4iLCJTVFJJS0UiLCJTVFJPTkciLCJTVUIiLCJTVU1NQVJZIiwi
+U1VQIiwiVEFCTEUiLCJUQk9EWSIsIlREIiwiVEVYVEFSRUEiLCJURk9PVCIsIlRIIiwiVEhFQUQiLCJU
+SU1FIiwiVFIiLCJUUkFDSyIsIlRUIiwiVSIsIlVMIiwiVkFSIiwiVklERU8iLCJXQlIiXSx0Lk4pfSkK
+cygkLCJYNCIsImhHIixmdW5jdGlvbigpe3JldHVybiBQLm51KCJeXFxTKyQiKX0pCnMoJCwid08iLCJv
+dyIsZnVuY3Rpb24oKXtyZXR1cm4gUC5ORChzZWxmKX0pCnMoJCwia3QiLCJSOCIsZnVuY3Rpb24oKXty
+ZXR1cm4gSC5ZZygiXyRkYXJ0X2RhcnRPYmplY3QiKX0pCnMoJCwiZksiLCJrSSIsZnVuY3Rpb24oKXty
+ZXR1cm4gZnVuY3Rpb24gRGFydE9iamVjdChhKXt0aGlzLm89YX19KQpyKCQsInF0IiwiekIiLGZ1bmN0
+aW9uKCl7cmV0dXJuIG5ldyBULm1RKCl9KQpyKCQsIk9sIiwiVUUiLGZ1bmN0aW9uKCl7cmV0dXJuIFAu
+aEsoQy5vbC5nbVcoVy54MygpKS5ocmVmKS5naFkoKS5xKDAsImF1dGhUb2tlbiIpfSkKcigkLCJoVCIs
+InlQIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiLmVkaXQtbGlzdCAucGFu
+ZWwtY29udGVudCIpfSkKcigkLCJXNiIsImhMIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlT
+ZWxlY3RvcigiLmVkaXQtcGFuZWwgLnBhbmVsLWNvbnRlbnQiKX0pCnIoJCwiVFIiLCJEVyIsZnVuY3Rp
+b24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoImZvb3RlciIpfSkKcigkLCJFWSIsImZpIixm
+dW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiaGVhZGVyIil9KQpyKCQsImJBIiwi
+YzAiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIjbWlncmF0ZS11bml0LXN0
+YXR1cy1pY29uIil9KQpyKCQsInQwIiwiYk4iLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNl
+bGVjdG9yKCIjbWlncmF0ZS11bml0LXN0YXR1cy1pY29uLWxhYmVsIil9KQpyKCQsImF2IiwiRDkiLGZ1
+bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIjdW5pdC1uYW1lIil9KQpyKCQsImZl
+IiwiS0ciLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBMLlhBKCl9KQpzKCQsImVvIiwiblUiLGZ1bmN0aW9u
+KCl7cmV0dXJuIG5ldyBNLmxJKCQuSGsoKSl9KQpzKCQsInlyIiwiYkQiLGZ1bmN0aW9uKCl7cmV0dXJu
+IG5ldyBFLk9GKFAubnUoIi8iKSxQLm51KCJbXi9dJCIpLFAubnUoIl4vIikpfSkKcygkLCJNayIsIktr
+IixmdW5jdGlvbigpe3JldHVybiBuZXcgTC5JVihQLm51KCJbL1xcXFxdIiksUC5udSgiW14vXFxcXF0k
+IiksUC5udSgiXihcXFxcXFxcXFteXFxcXF0rXFxcXFteXFxcXC9dK3xbYS16QS1aXTpbL1xcXFxdKSIp
+LFAubnUoIl5bL1xcXFxdKD8hWy9cXFxcXSkiKSl9KQpzKCQsImFrIiwiRWIiLGZ1bmN0aW9uKCl7cmV0
+dXJuIG5ldyBGLnJ1KFAubnUoIi8iKSxQLm51KCIoXlthLXpBLVpdWy0rLmEtekEtWlxcZF0qOi8vfFte
+L10pJCIpLFAubnUoIlthLXpBLVpdWy0rLmEtekEtWlxcZF0qOi8vW14vXSoiKSxQLm51KCJeLyIpKX0p
+CnMoJCwibHMiLCJIayIsZnVuY3Rpb24oKXtyZXR1cm4gTy5SaCgpfSl9KSgpOyhmdW5jdGlvbiBuYXRp
+dmVTdXBwb3J0KCl7IWZ1bmN0aW9uKCl7dmFyIHM9ZnVuY3Rpb24oYSl7dmFyIG09e30KbVthXT0xCnJl
+dHVybiBPYmplY3Qua2V5cyhodW5rSGVscGVycy5jb252ZXJ0VG9GYXN0T2JqZWN0KG0pKVswXX0Kdi5n
+ZXRJc29sYXRlVGFnPWZ1bmN0aW9uKGEpe3JldHVybiBzKCJfX19kYXJ0XyIrYSt2Lmlzb2xhdGVUYWcp
+fQp2YXIgcj0iX19fZGFydF9pc29sYXRlX3RhZ3NfIgp2YXIgcT1PYmplY3Rbcl18fChPYmplY3Rbcl09
+T2JqZWN0LmNyZWF0ZShudWxsKSkKdmFyIHA9Il9aeFl4WCIKZm9yKHZhciBvPTA7O28rKyl7dmFyIG49
+cyhwKyJfIitvKyJfIikKaWYoIShuIGluIHEpKXtxW25dPTEKdi5pc29sYXRlVGFnPW4KYnJlYWt9fXYu
+ZGlzcGF0Y2hQcm9wZXJ0eU5hbWU9di5nZXRJc29sYXRlVGFnKCJkaXNwYXRjaF9yZWNvcmQiKX0oKQpo
+dW5rSGVscGVycy5zZXRPclVwZGF0ZUludGVyY2VwdG9yc0J5VGFnKHtET01FcnJvcjpKLkd2LE1lZGlh
+RXJyb3I6Si5HdixOYXZpZ2F0b3I6Si5HdixOYXZpZ2F0b3JDb25jdXJyZW50SGFyZHdhcmU6Si5HdixO
+YXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjpKLkd2LE92ZXJjb25zdHJhaW5lZEVycm9yOkouR3YsUG9zaXRp
+b25FcnJvcjpKLkd2LEdlb2xvY2F0aW9uUG9zaXRpb25FcnJvcjpKLkd2LFJhbmdlOkouR3YsU1FMRXJy
+b3I6Si5HdixEYXRhVmlldzpILkVULEFycmF5QnVmZmVyVmlldzpILkVULEZsb2F0MzJBcnJheTpILkRn
+LEZsb2F0NjRBcnJheTpILkRnLEludDE2QXJyYXk6SC54aixJbnQzMkFycmF5OkguZEUsSW50OEFycmF5
+OkguWkEsVWludDE2QXJyYXk6SC5kVCxVaW50MzJBcnJheTpILlBxLFVpbnQ4Q2xhbXBlZEFycmF5Okgu
+ZUUsQ2FudmFzUGl4ZWxBcnJheTpILmVFLFVpbnQ4QXJyYXk6SC5WNixIVE1MQXVkaW9FbGVtZW50Olcu
+cUUsSFRNTEJSRWxlbWVudDpXLnFFLEhUTUxCdXR0b25FbGVtZW50OlcucUUsSFRNTENhbnZhc0VsZW1l
+bnQ6Vy5xRSxIVE1MQ29udGVudEVsZW1lbnQ6Vy5xRSxIVE1MRExpc3RFbGVtZW50OlcucUUsSFRNTERh
+dGFFbGVtZW50OlcucUUsSFRNTERhdGFMaXN0RWxlbWVudDpXLnFFLEhUTUxEZXRhaWxzRWxlbWVudDpX
+LnFFLEhUTUxEaWFsb2dFbGVtZW50OlcucUUsSFRNTERpdkVsZW1lbnQ6Vy5xRSxIVE1MRW1iZWRFbGVt
+ZW50OlcucUUsSFRNTEZpZWxkU2V0RWxlbWVudDpXLnFFLEhUTUxIUkVsZW1lbnQ6Vy5xRSxIVE1MSGVh
+ZEVsZW1lbnQ6Vy5xRSxIVE1MSGVhZGluZ0VsZW1lbnQ6Vy5xRSxIVE1MSHRtbEVsZW1lbnQ6Vy5xRSxI
+VE1MSUZyYW1lRWxlbWVudDpXLnFFLEhUTUxJbWFnZUVsZW1lbnQ6Vy5xRSxIVE1MSW5wdXRFbGVtZW50
+OlcucUUsSFRNTExJRWxlbWVudDpXLnFFLEhUTUxMYWJlbEVsZW1lbnQ6Vy5xRSxIVE1MTGVnZW5kRWxl
+bWVudDpXLnFFLEhUTUxMaW5rRWxlbWVudDpXLnFFLEhUTUxNYXBFbGVtZW50OlcucUUsSFRNTE1lZGlh
+RWxlbWVudDpXLnFFLEhUTUxNZW51RWxlbWVudDpXLnFFLEhUTUxNZXRhRWxlbWVudDpXLnFFLEhUTUxN
+ZXRlckVsZW1lbnQ6Vy5xRSxIVE1MTW9kRWxlbWVudDpXLnFFLEhUTUxPTGlzdEVsZW1lbnQ6Vy5xRSxI
+VE1MT2JqZWN0RWxlbWVudDpXLnFFLEhUTUxPcHRHcm91cEVsZW1lbnQ6Vy5xRSxIVE1MT3B0aW9uRWxl
+bWVudDpXLnFFLEhUTUxPdXRwdXRFbGVtZW50OlcucUUsSFRNTFBhcmFtRWxlbWVudDpXLnFFLEhUTUxQ
+aWN0dXJlRWxlbWVudDpXLnFFLEhUTUxQcmVFbGVtZW50OlcucUUsSFRNTFByb2dyZXNzRWxlbWVudDpX
+LnFFLEhUTUxRdW90ZUVsZW1lbnQ6Vy5xRSxIVE1MU2NyaXB0RWxlbWVudDpXLnFFLEhUTUxTaGFkb3dF
+bGVtZW50OlcucUUsSFRNTFNsb3RFbGVtZW50OlcucUUsSFRNTFNvdXJjZUVsZW1lbnQ6Vy5xRSxIVE1M
+U3BhbkVsZW1lbnQ6Vy5xRSxIVE1MU3R5bGVFbGVtZW50OlcucUUsSFRNTFRhYmxlQ2FwdGlvbkVsZW1l
+bnQ6Vy5xRSxIVE1MVGFibGVDZWxsRWxlbWVudDpXLnFFLEhUTUxUYWJsZURhdGFDZWxsRWxlbWVudDpX
+LnFFLEhUTUxUYWJsZUhlYWRlckNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlQ29sRWxlbWVudDpXLnFF
+LEhUTUxUZXh0QXJlYUVsZW1lbnQ6Vy5xRSxIVE1MVGltZUVsZW1lbnQ6Vy5xRSxIVE1MVGl0bGVFbGVt
+ZW50OlcucUUsSFRNTFRyYWNrRWxlbWVudDpXLnFFLEhUTUxVTGlzdEVsZW1lbnQ6Vy5xRSxIVE1MVW5r
+bm93bkVsZW1lbnQ6Vy5xRSxIVE1MVmlkZW9FbGVtZW50OlcucUUsSFRNTERpcmVjdG9yeUVsZW1lbnQ6
+Vy5xRSxIVE1MRm9udEVsZW1lbnQ6Vy5xRSxIVE1MRnJhbWVFbGVtZW50OlcucUUsSFRNTEZyYW1lU2V0
+RWxlbWVudDpXLnFFLEhUTUxNYXJxdWVlRWxlbWVudDpXLnFFLEhUTUxFbGVtZW50OlcucUUsSFRNTEFu
+Y2hvckVsZW1lbnQ6Vy5HaCxIVE1MQXJlYUVsZW1lbnQ6Vy5mWSxIVE1MQmFzZUVsZW1lbnQ6Vy5yWixC
+bG9iOlcuQXosSFRNTEJvZHlFbGVtZW50OlcuUVAsQ0RBVEFTZWN0aW9uOlcubngsQ2hhcmFjdGVyRGF0
+YTpXLm54LENvbW1lbnQ6Vy5ueCxQcm9jZXNzaW5nSW5zdHJ1Y3Rpb246Vy5ueCxUZXh0OlcubngsQ1NT
+U3R5bGVEZWNsYXJhdGlvbjpXLm9KLE1TU3R5bGVDU1NQcm9wZXJ0aWVzOlcub0osQ1NTMlByb3BlcnRp
+ZXM6Vy5vSixYTUxEb2N1bWVudDpXLlFGLERvY3VtZW50OlcuUUYsRE9NRXhjZXB0aW9uOlcuTmgsRE9N
+SW1wbGVtZW50YXRpb246Vy5hZSxET01SZWN0UmVhZE9ubHk6Vy5JQixET01Ub2tlbkxpc3Q6Vy5OUSxF
+bGVtZW50OlcuY3YsQWJvcnRQYXltZW50RXZlbnQ6Vy5lYSxBbmltYXRpb25FdmVudDpXLmVhLEFuaW1h
+dGlvblBsYXliYWNrRXZlbnQ6Vy5lYSxBcHBsaWNhdGlvbkNhY2hlRXJyb3JFdmVudDpXLmVhLEJhY2tn
+cm91bmRGZXRjaENsaWNrRXZlbnQ6Vy5lYSxCYWNrZ3JvdW5kRmV0Y2hFdmVudDpXLmVhLEJhY2tncm91
+bmRGZXRjaEZhaWxFdmVudDpXLmVhLEJhY2tncm91bmRGZXRjaGVkRXZlbnQ6Vy5lYSxCZWZvcmVJbnN0
+YWxsUHJvbXB0RXZlbnQ6Vy5lYSxCZWZvcmVVbmxvYWRFdmVudDpXLmVhLEJsb2JFdmVudDpXLmVhLENh
+bk1ha2VQYXltZW50RXZlbnQ6Vy5lYSxDbGlwYm9hcmRFdmVudDpXLmVhLENsb3NlRXZlbnQ6Vy5lYSxD
+dXN0b21FdmVudDpXLmVhLERldmljZU1vdGlvbkV2ZW50OlcuZWEsRGV2aWNlT3JpZW50YXRpb25FdmVu
+dDpXLmVhLEVycm9yRXZlbnQ6Vy5lYSxFeHRlbmRhYmxlRXZlbnQ6Vy5lYSxFeHRlbmRhYmxlTWVzc2Fn
+ZUV2ZW50OlcuZWEsRmV0Y2hFdmVudDpXLmVhLEZvbnRGYWNlU2V0TG9hZEV2ZW50OlcuZWEsRm9yZWln
+bkZldGNoRXZlbnQ6Vy5lYSxHYW1lcGFkRXZlbnQ6Vy5lYSxIYXNoQ2hhbmdlRXZlbnQ6Vy5lYSxJbnN0
+YWxsRXZlbnQ6Vy5lYSxNZWRpYUVuY3J5cHRlZEV2ZW50OlcuZWEsTWVkaWFLZXlNZXNzYWdlRXZlbnQ6
+Vy5lYSxNZWRpYVF1ZXJ5TGlzdEV2ZW50OlcuZWEsTWVkaWFTdHJlYW1FdmVudDpXLmVhLE1lZGlhU3Ry
+ZWFtVHJhY2tFdmVudDpXLmVhLE1lc3NhZ2VFdmVudDpXLmVhLE1JRElDb25uZWN0aW9uRXZlbnQ6Vy5l
+YSxNSURJTWVzc2FnZUV2ZW50OlcuZWEsTXV0YXRpb25FdmVudDpXLmVhLE5vdGlmaWNhdGlvbkV2ZW50
+OlcuZWEsUGFnZVRyYW5zaXRpb25FdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0RXZlbnQ6Vy5lYSxQYXlt
+ZW50UmVxdWVzdFVwZGF0ZUV2ZW50OlcuZWEsUG9wU3RhdGVFdmVudDpXLmVhLFByZXNlbnRhdGlvbkNv
+bm5lY3Rpb25BdmFpbGFibGVFdmVudDpXLmVhLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25DbG9zZUV2ZW50
+OlcuZWEsUHJvbWlzZVJlamVjdGlvbkV2ZW50OlcuZWEsUHVzaEV2ZW50OlcuZWEsUlRDRGF0YUNoYW5u
+ZWxFdmVudDpXLmVhLFJUQ0RUTUZUb25lQ2hhbmdlRXZlbnQ6Vy5lYSxSVENQZWVyQ29ubmVjdGlvbklj
+ZUV2ZW50OlcuZWEsUlRDVHJhY2tFdmVudDpXLmVhLFNlY3VyaXR5UG9saWN5VmlvbGF0aW9uRXZlbnQ6
+Vy5lYSxTZW5zb3JFcnJvckV2ZW50OlcuZWEsU3BlZWNoUmVjb2duaXRpb25FcnJvcjpXLmVhLFNwZWVj
+aFJlY29nbml0aW9uRXZlbnQ6Vy5lYSxTcGVlY2hTeW50aGVzaXNFdmVudDpXLmVhLFN0b3JhZ2VFdmVu
+dDpXLmVhLFN5bmNFdmVudDpXLmVhLFRyYWNrRXZlbnQ6Vy5lYSxUcmFuc2l0aW9uRXZlbnQ6Vy5lYSxX
+ZWJLaXRUcmFuc2l0aW9uRXZlbnQ6Vy5lYSxWUkRldmljZUV2ZW50OlcuZWEsVlJEaXNwbGF5RXZlbnQ6
+Vy5lYSxWUlNlc3Npb25FdmVudDpXLmVhLE1vam9JbnRlcmZhY2VSZXF1ZXN0RXZlbnQ6Vy5lYSxVU0JD
+b25uZWN0aW9uRXZlbnQ6Vy5lYSxJREJWZXJzaW9uQ2hhbmdlRXZlbnQ6Vy5lYSxBdWRpb1Byb2Nlc3Np
+bmdFdmVudDpXLmVhLE9mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudDpXLmVhLFdlYkdMQ29udGV4dEV2
+ZW50OlcuZWEsRXZlbnQ6Vy5lYSxJbnB1dEV2ZW50OlcuZWEsU3VibWl0RXZlbnQ6Vy5lYSxFdmVudFRh
+cmdldDpXLkQwLEZpbGU6Vy5oSCxIVE1MRm9ybUVsZW1lbnQ6Vy5oNCxIaXN0b3J5OlcuYnIsSFRNTERv
+Y3VtZW50OlcuVmIsWE1MSHR0cFJlcXVlc3Q6Vy5mSixYTUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0Olcu
+d2EsSW1hZ2VEYXRhOlcuU2csTG9jYXRpb246Vy53NyxNb3VzZUV2ZW50OlcuQWosRHJhZ0V2ZW50Olcu
+QWosUG9pbnRlckV2ZW50OlcuQWosV2hlZWxFdmVudDpXLkFqLERvY3VtZW50RnJhZ21lbnQ6Vy51SCxT
+aGFkb3dSb290OlcudUgsRG9jdW1lbnRUeXBlOlcudUgsTm9kZTpXLnVILE5vZGVMaXN0OlcuQkgsUmFk
+aW9Ob2RlTGlzdDpXLkJILEhUTUxQYXJhZ3JhcGhFbGVtZW50OlcuU04sUHJvZ3Jlc3NFdmVudDpXLmV3
+LFJlc291cmNlUHJvZ3Jlc3NFdmVudDpXLmV3LEhUTUxTZWxlY3RFbGVtZW50OlcubHAsSFRNTFRhYmxl
+RWxlbWVudDpXLlRiLEhUTUxUYWJsZVJvd0VsZW1lbnQ6Vy5JdixIVE1MVGFibGVTZWN0aW9uRWxlbWVu
+dDpXLldQLEhUTUxUZW1wbGF0ZUVsZW1lbnQ6Vy55WSxDb21wb3NpdGlvbkV2ZW50OlcudzYsRm9jdXNF
+dmVudDpXLnc2LEtleWJvYXJkRXZlbnQ6Vy53NixUZXh0RXZlbnQ6Vy53NixUb3VjaEV2ZW50OlcudzYs
+VUlFdmVudDpXLnc2LFdpbmRvdzpXLks1LERPTVdpbmRvdzpXLks1LERlZGljYXRlZFdvcmtlckdsb2Jh
+bFNjb3BlOlcuQ20sU2VydmljZVdvcmtlckdsb2JhbFNjb3BlOlcuQ20sU2hhcmVkV29ya2VyR2xvYmFs
+U2NvcGU6Vy5DbSxXb3JrZXJHbG9iYWxTY29wZTpXLkNtLEF0dHI6Vy5DUSxDbGllbnRSZWN0OlcudzQs
+RE9NUmVjdDpXLnc0LE5hbWVkTm9kZU1hcDpXLnJoLE1vek5hbWVkQXR0ck1hcDpXLnJoLElEQktleVJh
+bmdlOlAuaEYsU1ZHU2NyaXB0RWxlbWVudDpQLm5kLFNWR0FFbGVtZW50OlAuaGksU1ZHQW5pbWF0ZUVs
+ZW1lbnQ6UC5oaSxTVkdBbmltYXRlTW90aW9uRWxlbWVudDpQLmhpLFNWR0FuaW1hdGVUcmFuc2Zvcm1F
+bGVtZW50OlAuaGksU1ZHQW5pbWF0aW9uRWxlbWVudDpQLmhpLFNWR0NpcmNsZUVsZW1lbnQ6UC5oaSxT
+VkdDbGlwUGF0aEVsZW1lbnQ6UC5oaSxTVkdEZWZzRWxlbWVudDpQLmhpLFNWR0Rlc2NFbGVtZW50OlAu
+aGksU1ZHRGlzY2FyZEVsZW1lbnQ6UC5oaSxTVkdFbGxpcHNlRWxlbWVudDpQLmhpLFNWR0ZFQmxlbmRF
+bGVtZW50OlAuaGksU1ZHRkVDb2xvck1hdHJpeEVsZW1lbnQ6UC5oaSxTVkdGRUNvbXBvbmVudFRyYW5z
+ZmVyRWxlbWVudDpQLmhpLFNWR0ZFQ29tcG9zaXRlRWxlbWVudDpQLmhpLFNWR0ZFQ29udm9sdmVNYXRy
+aXhFbGVtZW50OlAuaGksU1ZHRkVEaWZmdXNlTGlnaHRpbmdFbGVtZW50OlAuaGksU1ZHRkVEaXNwbGFj
+ZW1lbnRNYXBFbGVtZW50OlAuaGksU1ZHRkVEaXN0YW50TGlnaHRFbGVtZW50OlAuaGksU1ZHRkVGbG9v
+ZEVsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNBRWxlbWVudDpQLmhpLFNWR0ZFRnVuY0JFbGVtZW50OlAuaGks
+U1ZHRkVGdW5jR0VsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNSRWxlbWVudDpQLmhpLFNWR0ZFR2F1c3NpYW5C
+bHVyRWxlbWVudDpQLmhpLFNWR0ZFSW1hZ2VFbGVtZW50OlAuaGksU1ZHRkVNZXJnZUVsZW1lbnQ6UC5o
+aSxTVkdGRU1lcmdlTm9kZUVsZW1lbnQ6UC5oaSxTVkdGRU1vcnBob2xvZ3lFbGVtZW50OlAuaGksU1ZH
+RkVPZmZzZXRFbGVtZW50OlAuaGksU1ZHRkVQb2ludExpZ2h0RWxlbWVudDpQLmhpLFNWR0ZFU3BlY3Vs
+YXJMaWdodGluZ0VsZW1lbnQ6UC5oaSxTVkdGRVNwb3RMaWdodEVsZW1lbnQ6UC5oaSxTVkdGRVRpbGVF
+bGVtZW50OlAuaGksU1ZHRkVUdXJidWxlbmNlRWxlbWVudDpQLmhpLFNWR0ZpbHRlckVsZW1lbnQ6UC5o
+aSxTVkdGb3JlaWduT2JqZWN0RWxlbWVudDpQLmhpLFNWR0dFbGVtZW50OlAuaGksU1ZHR2VvbWV0cnlF
+bGVtZW50OlAuaGksU1ZHR3JhcGhpY3NFbGVtZW50OlAuaGksU1ZHSW1hZ2VFbGVtZW50OlAuaGksU1ZH
+TGluZUVsZW1lbnQ6UC5oaSxTVkdMaW5lYXJHcmFkaWVudEVsZW1lbnQ6UC5oaSxTVkdNYXJrZXJFbGVt
+ZW50OlAuaGksU1ZHTWFza0VsZW1lbnQ6UC5oaSxTVkdNZXRhZGF0YUVsZW1lbnQ6UC5oaSxTVkdQYXRo
+RWxlbWVudDpQLmhpLFNWR1BhdHRlcm5FbGVtZW50OlAuaGksU1ZHUG9seWdvbkVsZW1lbnQ6UC5oaSxT
+VkdQb2x5bGluZUVsZW1lbnQ6UC5oaSxTVkdSYWRpYWxHcmFkaWVudEVsZW1lbnQ6UC5oaSxTVkdSZWN0
+RWxlbWVudDpQLmhpLFNWR1NldEVsZW1lbnQ6UC5oaSxTVkdTdG9wRWxlbWVudDpQLmhpLFNWR1N0eWxl
+RWxlbWVudDpQLmhpLFNWR1NWR0VsZW1lbnQ6UC5oaSxTVkdTd2l0Y2hFbGVtZW50OlAuaGksU1ZHU3lt
+Ym9sRWxlbWVudDpQLmhpLFNWR1RTcGFuRWxlbWVudDpQLmhpLFNWR1RleHRDb250ZW50RWxlbWVudDpQ
+LmhpLFNWR1RleHRFbGVtZW50OlAuaGksU1ZHVGV4dFBhdGhFbGVtZW50OlAuaGksU1ZHVGV4dFBvc2l0
+aW9uaW5nRWxlbWVudDpQLmhpLFNWR1RpdGxlRWxlbWVudDpQLmhpLFNWR1VzZUVsZW1lbnQ6UC5oaSxT
+VkdWaWV3RWxlbWVudDpQLmhpLFNWR0dyYWRpZW50RWxlbWVudDpQLmhpLFNWR0NvbXBvbmVudFRyYW5z
+ZmVyRnVuY3Rpb25FbGVtZW50OlAuaGksU1ZHRkVEcm9wU2hhZG93RWxlbWVudDpQLmhpLFNWR01QYXRo
+RWxlbWVudDpQLmhpLFNWR0VsZW1lbnQ6UC5oaX0pCmh1bmtIZWxwZXJzLnNldE9yVXBkYXRlTGVhZlRh
+Z3Moe0RPTUVycm9yOnRydWUsTWVkaWFFcnJvcjp0cnVlLE5hdmlnYXRvcjp0cnVlLE5hdmlnYXRvckNv
+bmN1cnJlbnRIYXJkd2FyZTp0cnVlLE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOnRydWUsT3ZlcmNvbnN0
+cmFpbmVkRXJyb3I6dHJ1ZSxQb3NpdGlvbkVycm9yOnRydWUsR2VvbG9jYXRpb25Qb3NpdGlvbkVycm9y
+OnRydWUsUmFuZ2U6dHJ1ZSxTUUxFcnJvcjp0cnVlLERhdGFWaWV3OnRydWUsQXJyYXlCdWZmZXJWaWV3
+OmZhbHNlLEZsb2F0MzJBcnJheTp0cnVlLEZsb2F0NjRBcnJheTp0cnVlLEludDE2QXJyYXk6dHJ1ZSxJ
+bnQzMkFycmF5OnRydWUsSW50OEFycmF5OnRydWUsVWludDE2QXJyYXk6dHJ1ZSxVaW50MzJBcnJheTp0
+cnVlLFVpbnQ4Q2xhbXBlZEFycmF5OnRydWUsQ2FudmFzUGl4ZWxBcnJheTp0cnVlLFVpbnQ4QXJyYXk6
+ZmFsc2UsSFRNTEF1ZGlvRWxlbWVudDp0cnVlLEhUTUxCUkVsZW1lbnQ6dHJ1ZSxIVE1MQnV0dG9uRWxl
+bWVudDp0cnVlLEhUTUxDYW52YXNFbGVtZW50OnRydWUsSFRNTENvbnRlbnRFbGVtZW50OnRydWUsSFRN
+TERMaXN0RWxlbWVudDp0cnVlLEhUTUxEYXRhRWxlbWVudDp0cnVlLEhUTUxEYXRhTGlzdEVsZW1lbnQ6
+dHJ1ZSxIVE1MRGV0YWlsc0VsZW1lbnQ6dHJ1ZSxIVE1MRGlhbG9nRWxlbWVudDp0cnVlLEhUTUxEaXZF
+bGVtZW50OnRydWUsSFRNTEVtYmVkRWxlbWVudDp0cnVlLEhUTUxGaWVsZFNldEVsZW1lbnQ6dHJ1ZSxI
+VE1MSFJFbGVtZW50OnRydWUsSFRNTEhlYWRFbGVtZW50OnRydWUsSFRNTEhlYWRpbmdFbGVtZW50OnRy
+dWUsSFRNTEh0bWxFbGVtZW50OnRydWUsSFRNTElGcmFtZUVsZW1lbnQ6dHJ1ZSxIVE1MSW1hZ2VFbGVt
+ZW50OnRydWUsSFRNTElucHV0RWxlbWVudDp0cnVlLEhUTUxMSUVsZW1lbnQ6dHJ1ZSxIVE1MTGFiZWxF
+bGVtZW50OnRydWUsSFRNTExlZ2VuZEVsZW1lbnQ6dHJ1ZSxIVE1MTGlua0VsZW1lbnQ6dHJ1ZSxIVE1M
+TWFwRWxlbWVudDp0cnVlLEhUTUxNZWRpYUVsZW1lbnQ6dHJ1ZSxIVE1MTWVudUVsZW1lbnQ6dHJ1ZSxI
+VE1MTWV0YUVsZW1lbnQ6dHJ1ZSxIVE1MTWV0ZXJFbGVtZW50OnRydWUsSFRNTE1vZEVsZW1lbnQ6dHJ1
+ZSxIVE1MT0xpc3RFbGVtZW50OnRydWUsSFRNTE9iamVjdEVsZW1lbnQ6dHJ1ZSxIVE1MT3B0R3JvdXBF
+bGVtZW50OnRydWUsSFRNTE9wdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MT3V0cHV0RWxlbWVudDp0cnVlLEhU
+TUxQYXJhbUVsZW1lbnQ6dHJ1ZSxIVE1MUGljdHVyZUVsZW1lbnQ6dHJ1ZSxIVE1MUHJlRWxlbWVudDp0
+cnVlLEhUTUxQcm9ncmVzc0VsZW1lbnQ6dHJ1ZSxIVE1MUXVvdGVFbGVtZW50OnRydWUsSFRNTFNjcmlw
+dEVsZW1lbnQ6dHJ1ZSxIVE1MU2hhZG93RWxlbWVudDp0cnVlLEhUTUxTbG90RWxlbWVudDp0cnVlLEhU
+TUxTb3VyY2VFbGVtZW50OnRydWUsSFRNTFNwYW5FbGVtZW50OnRydWUsSFRNTFN0eWxlRWxlbWVudDp0
+cnVlLEhUTUxUYWJsZUNhcHRpb25FbGVtZW50OnRydWUsSFRNTFRhYmxlQ2VsbEVsZW1lbnQ6dHJ1ZSxI
+VE1MVGFibGVEYXRhQ2VsbEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVIZWFkZXJDZWxsRWxlbWVudDp0cnVl
+LEhUTUxUYWJsZUNvbEVsZW1lbnQ6dHJ1ZSxIVE1MVGV4dEFyZWFFbGVtZW50OnRydWUsSFRNTFRpbWVF
+bGVtZW50OnRydWUsSFRNTFRpdGxlRWxlbWVudDp0cnVlLEhUTUxUcmFja0VsZW1lbnQ6dHJ1ZSxIVE1M
+VUxpc3RFbGVtZW50OnRydWUsSFRNTFVua25vd25FbGVtZW50OnRydWUsSFRNTFZpZGVvRWxlbWVudDp0
+cnVlLEhUTUxEaXJlY3RvcnlFbGVtZW50OnRydWUsSFRNTEZvbnRFbGVtZW50OnRydWUsSFRNTEZyYW1l
+RWxlbWVudDp0cnVlLEhUTUxGcmFtZVNldEVsZW1lbnQ6dHJ1ZSxIVE1MTWFycXVlZUVsZW1lbnQ6dHJ1
+ZSxIVE1MRWxlbWVudDpmYWxzZSxIVE1MQW5jaG9yRWxlbWVudDp0cnVlLEhUTUxBcmVhRWxlbWVudDp0
+cnVlLEhUTUxCYXNlRWxlbWVudDp0cnVlLEJsb2I6ZmFsc2UsSFRNTEJvZHlFbGVtZW50OnRydWUsQ0RB
+VEFTZWN0aW9uOnRydWUsQ2hhcmFjdGVyRGF0YTp0cnVlLENvbW1lbnQ6dHJ1ZSxQcm9jZXNzaW5nSW5z
+dHJ1Y3Rpb246dHJ1ZSxUZXh0OnRydWUsQ1NTU3R5bGVEZWNsYXJhdGlvbjp0cnVlLE1TU3R5bGVDU1NQ
+cm9wZXJ0aWVzOnRydWUsQ1NTMlByb3BlcnRpZXM6dHJ1ZSxYTUxEb2N1bWVudDp0cnVlLERvY3VtZW50
+OmZhbHNlLERPTUV4Y2VwdGlvbjp0cnVlLERPTUltcGxlbWVudGF0aW9uOnRydWUsRE9NUmVjdFJlYWRP
+bmx5OmZhbHNlLERPTVRva2VuTGlzdDp0cnVlLEVsZW1lbnQ6ZmFsc2UsQWJvcnRQYXltZW50RXZlbnQ6
+dHJ1ZSxBbmltYXRpb25FdmVudDp0cnVlLEFuaW1hdGlvblBsYXliYWNrRXZlbnQ6dHJ1ZSxBcHBsaWNh
+dGlvbkNhY2hlRXJyb3JFdmVudDp0cnVlLEJhY2tncm91bmRGZXRjaENsaWNrRXZlbnQ6dHJ1ZSxCYWNr
+Z3JvdW5kRmV0Y2hFdmVudDp0cnVlLEJhY2tncm91bmRGZXRjaEZhaWxFdmVudDp0cnVlLEJhY2tncm91
+bmRGZXRjaGVkRXZlbnQ6dHJ1ZSxCZWZvcmVJbnN0YWxsUHJvbXB0RXZlbnQ6dHJ1ZSxCZWZvcmVVbmxv
+YWRFdmVudDp0cnVlLEJsb2JFdmVudDp0cnVlLENhbk1ha2VQYXltZW50RXZlbnQ6dHJ1ZSxDbGlwYm9h
+cmRFdmVudDp0cnVlLENsb3NlRXZlbnQ6dHJ1ZSxDdXN0b21FdmVudDp0cnVlLERldmljZU1vdGlvbkV2
+ZW50OnRydWUsRGV2aWNlT3JpZW50YXRpb25FdmVudDp0cnVlLEVycm9yRXZlbnQ6dHJ1ZSxFeHRlbmRh
+YmxlRXZlbnQ6dHJ1ZSxFeHRlbmRhYmxlTWVzc2FnZUV2ZW50OnRydWUsRmV0Y2hFdmVudDp0cnVlLEZv
+bnRGYWNlU2V0TG9hZEV2ZW50OnRydWUsRm9yZWlnbkZldGNoRXZlbnQ6dHJ1ZSxHYW1lcGFkRXZlbnQ6
+dHJ1ZSxIYXNoQ2hhbmdlRXZlbnQ6dHJ1ZSxJbnN0YWxsRXZlbnQ6dHJ1ZSxNZWRpYUVuY3J5cHRlZEV2
+ZW50OnRydWUsTWVkaWFLZXlNZXNzYWdlRXZlbnQ6dHJ1ZSxNZWRpYVF1ZXJ5TGlzdEV2ZW50OnRydWUs
+TWVkaWFTdHJlYW1FdmVudDp0cnVlLE1lZGlhU3RyZWFtVHJhY2tFdmVudDp0cnVlLE1lc3NhZ2VFdmVu
+dDp0cnVlLE1JRElDb25uZWN0aW9uRXZlbnQ6dHJ1ZSxNSURJTWVzc2FnZUV2ZW50OnRydWUsTXV0YXRp
+b25FdmVudDp0cnVlLE5vdGlmaWNhdGlvbkV2ZW50OnRydWUsUGFnZVRyYW5zaXRpb25FdmVudDp0cnVl
+LFBheW1lbnRSZXF1ZXN0RXZlbnQ6dHJ1ZSxQYXltZW50UmVxdWVzdFVwZGF0ZUV2ZW50OnRydWUsUG9w
+U3RhdGVFdmVudDp0cnVlLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25BdmFpbGFibGVFdmVudDp0cnVlLFBy
+ZXNlbnRhdGlvbkNvbm5lY3Rpb25DbG9zZUV2ZW50OnRydWUsUHJvbWlzZVJlamVjdGlvbkV2ZW50OnRy
+dWUsUHVzaEV2ZW50OnRydWUsUlRDRGF0YUNoYW5uZWxFdmVudDp0cnVlLFJUQ0RUTUZUb25lQ2hhbmdl
+RXZlbnQ6dHJ1ZSxSVENQZWVyQ29ubmVjdGlvbkljZUV2ZW50OnRydWUsUlRDVHJhY2tFdmVudDp0cnVl
+LFNlY3VyaXR5UG9saWN5VmlvbGF0aW9uRXZlbnQ6dHJ1ZSxTZW5zb3JFcnJvckV2ZW50OnRydWUsU3Bl
+ZWNoUmVjb2duaXRpb25FcnJvcjp0cnVlLFNwZWVjaFJlY29nbml0aW9uRXZlbnQ6dHJ1ZSxTcGVlY2hT
+eW50aGVzaXNFdmVudDp0cnVlLFN0b3JhZ2VFdmVudDp0cnVlLFN5bmNFdmVudDp0cnVlLFRyYWNrRXZl
+bnQ6dHJ1ZSxUcmFuc2l0aW9uRXZlbnQ6dHJ1ZSxXZWJLaXRUcmFuc2l0aW9uRXZlbnQ6dHJ1ZSxWUkRl
+dmljZUV2ZW50OnRydWUsVlJEaXNwbGF5RXZlbnQ6dHJ1ZSxWUlNlc3Npb25FdmVudDp0cnVlLE1vam9J
+bnRlcmZhY2VSZXF1ZXN0RXZlbnQ6dHJ1ZSxVU0JDb25uZWN0aW9uRXZlbnQ6dHJ1ZSxJREJWZXJzaW9u
+Q2hhbmdlRXZlbnQ6dHJ1ZSxBdWRpb1Byb2Nlc3NpbmdFdmVudDp0cnVlLE9mZmxpbmVBdWRpb0NvbXBs
+ZXRpb25FdmVudDp0cnVlLFdlYkdMQ29udGV4dEV2ZW50OnRydWUsRXZlbnQ6ZmFsc2UsSW5wdXRFdmVu
+dDpmYWxzZSxTdWJtaXRFdmVudDpmYWxzZSxFdmVudFRhcmdldDpmYWxzZSxGaWxlOnRydWUsSFRNTEZv
+cm1FbGVtZW50OnRydWUsSGlzdG9yeTp0cnVlLEhUTUxEb2N1bWVudDp0cnVlLFhNTEh0dHBSZXF1ZXN0
+OnRydWUsWE1MSHR0cFJlcXVlc3RFdmVudFRhcmdldDpmYWxzZSxJbWFnZURhdGE6dHJ1ZSxMb2NhdGlv
+bjp0cnVlLE1vdXNlRXZlbnQ6dHJ1ZSxEcmFnRXZlbnQ6dHJ1ZSxQb2ludGVyRXZlbnQ6dHJ1ZSxXaGVl
+bEV2ZW50OnRydWUsRG9jdW1lbnRGcmFnbWVudDp0cnVlLFNoYWRvd1Jvb3Q6dHJ1ZSxEb2N1bWVudFR5
+cGU6dHJ1ZSxOb2RlOmZhbHNlLE5vZGVMaXN0OnRydWUsUmFkaW9Ob2RlTGlzdDp0cnVlLEhUTUxQYXJh
+Z3JhcGhFbGVtZW50OnRydWUsUHJvZ3Jlc3NFdmVudDp0cnVlLFJlc291cmNlUHJvZ3Jlc3NFdmVudDp0
+cnVlLEhUTUxTZWxlY3RFbGVtZW50OnRydWUsSFRNTFRhYmxlRWxlbWVudDp0cnVlLEhUTUxUYWJsZVJv
+d0VsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVTZWN0aW9uRWxlbWVudDp0cnVlLEhUTUxUZW1wbGF0ZUVsZW1l
+bnQ6dHJ1ZSxDb21wb3NpdGlvbkV2ZW50OnRydWUsRm9jdXNFdmVudDp0cnVlLEtleWJvYXJkRXZlbnQ6
+dHJ1ZSxUZXh0RXZlbnQ6dHJ1ZSxUb3VjaEV2ZW50OnRydWUsVUlFdmVudDpmYWxzZSxXaW5kb3c6dHJ1
+ZSxET01XaW5kb3c6dHJ1ZSxEZWRpY2F0ZWRXb3JrZXJHbG9iYWxTY29wZTp0cnVlLFNlcnZpY2VXb3Jr
+ZXJHbG9iYWxTY29wZTp0cnVlLFNoYXJlZFdvcmtlckdsb2JhbFNjb3BlOnRydWUsV29ya2VyR2xvYmFs
+U2NvcGU6dHJ1ZSxBdHRyOnRydWUsQ2xpZW50UmVjdDp0cnVlLERPTVJlY3Q6dHJ1ZSxOYW1lZE5vZGVN
+YXA6dHJ1ZSxNb3pOYW1lZEF0dHJNYXA6dHJ1ZSxJREJLZXlSYW5nZTp0cnVlLFNWR1NjcmlwdEVsZW1l
+bnQ6dHJ1ZSxTVkdBRWxlbWVudDp0cnVlLFNWR0FuaW1hdGVFbGVtZW50OnRydWUsU1ZHQW5pbWF0ZU1v
+dGlvbkVsZW1lbnQ6dHJ1ZSxTVkdBbmltYXRlVHJhbnNmb3JtRWxlbWVudDp0cnVlLFNWR0FuaW1hdGlv
+bkVsZW1lbnQ6dHJ1ZSxTVkdDaXJjbGVFbGVtZW50OnRydWUsU1ZHQ2xpcFBhdGhFbGVtZW50OnRydWUs
+U1ZHRGVmc0VsZW1lbnQ6dHJ1ZSxTVkdEZXNjRWxlbWVudDp0cnVlLFNWR0Rpc2NhcmRFbGVtZW50OnRy
+dWUsU1ZHRWxsaXBzZUVsZW1lbnQ6dHJ1ZSxTVkdGRUJsZW5kRWxlbWVudDp0cnVlLFNWR0ZFQ29sb3JN
+YXRyaXhFbGVtZW50OnRydWUsU1ZHRkVDb21wb25lbnRUcmFuc2ZlckVsZW1lbnQ6dHJ1ZSxTVkdGRUNv
+bXBvc2l0ZUVsZW1lbnQ6dHJ1ZSxTVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVudDp0cnVlLFNWR0ZFRGlm
+ZnVzZUxpZ2h0aW5nRWxlbWVudDp0cnVlLFNWR0ZFRGlzcGxhY2VtZW50TWFwRWxlbWVudDp0cnVlLFNW
+R0ZFRGlzdGFudExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFRmxvb2RFbGVtZW50OnRydWUsU1ZHRkVGdW5j
+QUVsZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNCRWxlbWVudDp0cnVlLFNWR0ZFRnVuY0dFbGVtZW50OnRydWUs
+U1ZHRkVGdW5jUkVsZW1lbnQ6dHJ1ZSxTVkdGRUdhdXNzaWFuQmx1ckVsZW1lbnQ6dHJ1ZSxTVkdGRUlt
+YWdlRWxlbWVudDp0cnVlLFNWR0ZFTWVyZ2VFbGVtZW50OnRydWUsU1ZHRkVNZXJnZU5vZGVFbGVtZW50
+OnRydWUsU1ZHRkVNb3JwaG9sb2d5RWxlbWVudDp0cnVlLFNWR0ZFT2Zmc2V0RWxlbWVudDp0cnVlLFNW
+R0ZFUG9pbnRMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVNwZWN1bGFyTGlnaHRpbmdFbGVtZW50OnRydWUs
+U1ZHRkVTcG90TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVUaWxlRWxlbWVudDp0cnVlLFNWR0ZFVHVyYnVs
+ZW5jZUVsZW1lbnQ6dHJ1ZSxTVkdGaWx0ZXJFbGVtZW50OnRydWUsU1ZHRm9yZWlnbk9iamVjdEVsZW1l
+bnQ6dHJ1ZSxTVkdHRWxlbWVudDp0cnVlLFNWR0dlb21ldHJ5RWxlbWVudDp0cnVlLFNWR0dyYXBoaWNz
+RWxlbWVudDp0cnVlLFNWR0ltYWdlRWxlbWVudDp0cnVlLFNWR0xpbmVFbGVtZW50OnRydWUsU1ZHTGlu
+ZWFyR3JhZGllbnRFbGVtZW50OnRydWUsU1ZHTWFya2VyRWxlbWVudDp0cnVlLFNWR01hc2tFbGVtZW50
+OnRydWUsU1ZHTWV0YWRhdGFFbGVtZW50OnRydWUsU1ZHUGF0aEVsZW1lbnQ6dHJ1ZSxTVkdQYXR0ZXJu
+RWxlbWVudDp0cnVlLFNWR1BvbHlnb25FbGVtZW50OnRydWUsU1ZHUG9seWxpbmVFbGVtZW50OnRydWUs
+U1ZHUmFkaWFsR3JhZGllbnRFbGVtZW50OnRydWUsU1ZHUmVjdEVsZW1lbnQ6dHJ1ZSxTVkdTZXRFbGVt
+ZW50OnRydWUsU1ZHU3RvcEVsZW1lbnQ6dHJ1ZSxTVkdTdHlsZUVsZW1lbnQ6dHJ1ZSxTVkdTVkdFbGVt
+ZW50OnRydWUsU1ZHU3dpdGNoRWxlbWVudDp0cnVlLFNWR1N5bWJvbEVsZW1lbnQ6dHJ1ZSxTVkdUU3Bh
+bkVsZW1lbnQ6dHJ1ZSxTVkdUZXh0Q29udGVudEVsZW1lbnQ6dHJ1ZSxTVkdUZXh0RWxlbWVudDp0cnVl
+LFNWR1RleHRQYXRoRWxlbWVudDp0cnVlLFNWR1RleHRQb3NpdGlvbmluZ0VsZW1lbnQ6dHJ1ZSxTVkdU
+aXRsZUVsZW1lbnQ6dHJ1ZSxTVkdVc2VFbGVtZW50OnRydWUsU1ZHVmlld0VsZW1lbnQ6dHJ1ZSxTVkdH
+cmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdDb21wb25lbnRUcmFuc2ZlckZ1bmN0aW9uRWxlbWVudDp0cnVl
+LFNWR0ZFRHJvcFNoYWRvd0VsZW1lbnQ6dHJ1ZSxTVkdNUGF0aEVsZW1lbnQ6dHJ1ZSxTVkdFbGVtZW50
+OmZhbHNlfSkKSC5MWi4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILlJHLiRu
+YXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguVlAuJG5hdGl2ZVN1cGVyY2xhc3NU
+YWc9IkFycmF5QnVmZmVyVmlldyIKSC5EZy4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJW
+aWV3IgpILldCLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguWkcuJG5hdGl2
+ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5QZy4kbmF0aXZlU3VwZXJjbGFzc1RhZz0i
+QXJyYXlCdWZmZXJWaWV3In0pKCkKY29udmVydEFsbFRvRmFzdE9iamVjdCh3KQpjb252ZXJ0VG9GYXN0
+T2JqZWN0KCQpOyhmdW5jdGlvbihhKXtpZih0eXBlb2YgZG9jdW1lbnQ9PT0idW5kZWZpbmVkIil7YShu
+dWxsKQpyZXR1cm59aWYodHlwZW9mIGRvY3VtZW50LmN1cnJlbnRTY3JpcHQhPSJ1bmRlZmluZWQiKXth
+KGRvY3VtZW50LmN1cnJlbnRTY3JpcHQpCnJldHVybn12YXIgcz1kb2N1bWVudC5zY3JpcHRzCmZ1bmN0
+aW9uIG9uTG9hZChiKXtmb3IodmFyIHE9MDtxPHMubGVuZ3RoOysrcSlzW3FdLnJlbW92ZUV2ZW50TGlz
+dGVuZXIoImxvYWQiLG9uTG9hZCxmYWxzZSkKYShiLnRhcmdldCl9Zm9yKHZhciByPTA7cjxzLmxlbmd0
+aDsrK3Ipc1tyXS5hZGRFdmVudExpc3RlbmVyKCJsb2FkIixvbkxvYWQsZmFsc2UpfSkoZnVuY3Rpb24o
+YSl7di5jdXJyZW50U2NyaXB0PWEKdmFyIHM9TC5JcQppZih0eXBlb2YgZGFydE1haW5SdW5uZXI9PT0i
+ZnVuY3Rpb24iKWRhcnRNYWluUnVubmVyKHMsW10pCmVsc2UgcyhbXSl9KX0pKCkKLy8jIHNvdXJjZU1h
+cHBpbmdVUkw9bWlncmF0aW9uLmpzLm1hcAo=
 ''';
diff --git a/pkg/nnbd_migration/lib/src/nullability_node.dart b/pkg/nnbd_migration/lib/src/nullability_node.dart
index 3f35f7b..d3da196 100644
--- a/pkg/nnbd_migration/lib/src/nullability_node.dart
+++ b/pkg/nnbd_migration/lib/src/nullability_node.dart
@@ -340,8 +340,7 @@
   /// nullability information from one node to another.
   PropagationResult propagate() {
     if (_debugBeforePropagation) debugDump();
-    var propagationState =
-        _PropagationState(always, never).result;
+    var propagationState = _PropagationState(always, never).result;
     if (_debugAfterPropagation) debugDump();
     return propagationState;
   }
diff --git a/pkg/nnbd_migration/tool/codegen/generate_resources.dart b/pkg/nnbd_migration/tool/codegen/generate_resources.dart
index 8de7d12..f80e0c31 100644
--- a/pkg/nnbd_migration/tool/codegen/generate_resources.dart
+++ b/pkg/nnbd_migration/tool/codegen/generate_resources.dart
@@ -157,6 +157,10 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+// This file is explicitly opted in to null safety since it contains `String?`
+// types, even though the rest of the migration tool isn't migrated yet.
+// @dart=2.12
+
 // This file is generated; don't edit it directly.
 //
 // See $filePath for how
@@ -196,7 +200,7 @@
     var delimiter = "'''";
 
     buf.writeln();
-    buf.writeln('String _$name;');
+    buf.writeln('String? _$name;');
     if (name == path.basename(javascriptOutput.path).replaceAll('.', '_')) {
       // Write out the crc for the dart code.
       var sourceCode = StringBuffer();
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index 8b3db04..df755a73 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -116,8 +116,6 @@
   V(assembly, assembly_filename)                                               \
   V(elf, elf_filename)                                                         \
   V(loading_unit_manifest, loading_unit_manifest_filename)                     \
-  V(load_compilation_trace, load_compilation_trace_filename)                   \
-  V(load_type_feedback, load_type_feedback_filename)                           \
   V(save_debugging_info, debugging_info_filename)                              \
   V(save_obfuscation_map, obfuscation_map_filename)
 
@@ -390,34 +388,6 @@
     Dart_Handle result = Dart_CompileAll();
     CHECK_RESULT(result);
   }
-
-  if ((load_compilation_trace_filename != NULL) &&
-      ((snapshot_kind == kCoreJIT) || (snapshot_kind == kAppJIT))) {
-    // Finalize all classes. This ensures that there are no non-finalized
-    // classes in the gaps between cid ranges. Such classes prevent merging of
-    // cid ranges.
-    Dart_Handle result = Dart_FinalizeAllClasses();
-    CHECK_RESULT(result);
-    // Sort classes to have better cid ranges.
-    result = Dart_SortClasses();
-    CHECK_RESULT(result);
-    uint8_t* buffer = NULL;
-    intptr_t size = 0;
-    ReadFile(load_compilation_trace_filename, &buffer, &size);
-    result = Dart_LoadCompilationTrace(buffer, size);
-    free(buffer);
-    CHECK_RESULT(result);
-  }
-
-  if ((load_type_feedback_filename != NULL) &&
-      ((snapshot_kind == kCoreJIT) || (snapshot_kind == kAppJIT))) {
-    uint8_t* buffer = NULL;
-    intptr_t size = 0;
-    ReadFile(load_type_feedback_filename, &buffer, &size);
-    Dart_Handle result = Dart_LoadTypeFeedback(buffer, size);
-    free(buffer);
-    CHECK_RESULT(result);
-  }
 }
 
 static void CreateAndWriteCoreSnapshot() {
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index 5b4601d..9610153 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -73,8 +73,6 @@
 
 static Dart_Isolate main_isolate = NULL;
 
-static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size);
-
 #define SAVE_ERROR_AND_EXIT(result)                                            \
   *error = Utils::StrDup(Dart_GetError(result));                               \
   if (Dart_IsCompilationError(result)) {                                       \
@@ -925,32 +923,6 @@
     ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
-static void WriteFile(const char* filename,
-                      const uint8_t* buffer,
-                      const intptr_t size) {
-  File* file = File::Open(NULL, filename, File::kWriteTruncate);
-  if (file == NULL) {
-    ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
-  }
-  if (!file->WriteFully(buffer, size)) {
-    ErrorExit(kErrorExitCode, "Unable to write file %s\n", filename);
-  }
-  file->Release();
-}
-
-static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size) {
-  File* file = File::Open(NULL, filename, File::kRead);
-  if (file == NULL) {
-    ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
-  }
-  *size = file->Length();
-  *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
-  if (!file->ReadFully(*buffer, *size)) {
-    ErrorExit(kErrorExitCode, "Unable to read file %s\n", filename);
-  }
-  file->Release();
-}
-
 void RunMainIsolate(const char* script_name,
                     const char* package_config_override,
                     CommandLineOptions* dart_options) {
@@ -1017,23 +989,6 @@
                 script_name);
     }
 
-    if (Options::load_compilation_trace_filename() != NULL) {
-      uint8_t* buffer = NULL;
-      intptr_t size = 0;
-      ReadFile(Options::load_compilation_trace_filename(), &buffer, &size);
-      result = Dart_LoadCompilationTrace(buffer, size);
-      free(buffer);
-      CHECK_RESULT(result);
-    }
-    if (Options::load_type_feedback_filename() != NULL) {
-      uint8_t* buffer = NULL;
-      intptr_t size = 0;
-      ReadFile(Options::load_type_feedback_filename(), &buffer, &size);
-      result = Dart_LoadTypeFeedback(buffer, size);
-      free(buffer);
-      CHECK_RESULT(result);
-    }
-
     // Create a closure for the main entry point which is in the exported
     // namespace of the root library or invoke a getter of the same name
     // in the exported namespace and return the resulting closure.
@@ -1068,21 +1023,6 @@
       }
     }
     CHECK_RESULT(result);
-
-    if (Options::save_compilation_trace_filename() != NULL) {
-      uint8_t* buffer = NULL;
-      intptr_t size = 0;
-      result = Dart_SaveCompilationTrace(&buffer, &size);
-      CHECK_RESULT(result);
-      WriteFile(Options::save_compilation_trace_filename(), buffer, size);
-    }
-    if (Options::save_type_feedback_filename() != NULL) {
-      uint8_t* buffer = NULL;
-      intptr_t size = 0;
-      result = Dart_SaveTypeFeedback(&buffer, &size);
-      CHECK_RESULT(result);
-      WriteFile(Options::save_type_feedback_filename(), buffer, size);
-    }
   }
 
   WriteDepsFile(isolate);
diff --git a/runtime/bin/main_options.h b/runtime/bin/main_options.h
index 4fab09c..8f9736d 100644
--- a/runtime/bin/main_options.h
+++ b/runtime/bin/main_options.h
@@ -23,10 +23,6 @@
   V(snapshot_depfile, snapshot_deps_filename)                                  \
   V(depfile, depfile)                                                          \
   V(depfile_output_filename, depfile_output_filename)                          \
-  V(save_compilation_trace, save_compilation_trace_filename)                   \
-  V(load_compilation_trace, load_compilation_trace_filename)                   \
-  V(save_type_feedback, save_type_feedback_filename)                           \
-  V(load_type_feedback, load_type_feedback_filename)                           \
   V(root_certs_file, root_certs_file)                                          \
   V(root_certs_cache, root_certs_cache)                                        \
   V(namespace, namespc)                                                        \
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index d8db597..a328eb7 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -3691,58 +3691,6 @@
 DART_EXPORT bool Dart_WriteProfileToTimeline(Dart_Port main_port, char** error);
 
 /*
- * ====================
- * Compilation Feedback
- * ====================
- */
-
-/**
- * Record all functions which have been compiled in the current isolate.
- *
- * \param buffer Returns a pointer to a buffer containing the trace.
- *   This buffer is scope allocated and is only valid  until the next call to
- *   Dart_ExitScope.
- * \param size Returns the size of the buffer.
- * \return Returns an valid handle upon success.
- */
-DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle
-Dart_SaveCompilationTrace(uint8_t** buffer, intptr_t* buffer_length);
-
-/**
- * Compile all functions from data from Dart_SaveCompilationTrace. Unlike JIT
- * feedback, this data is fuzzy: loading does not need to happen in the exact
- * program that was saved, the saver and loader do not need to agree on checked
- * mode versus production mode or debug/release/product.
- *
- * \return Returns an error handle if a compilation error was encountered.
- */
-DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle
-Dart_LoadCompilationTrace(uint8_t* buffer, intptr_t buffer_length);
-
-/**
- * Record runtime feedback for the current isolate, including type feedback
- * and usage counters.
- *
- * \param buffer Returns a pointer to a buffer containing the trace.
- *   This buffer is scope allocated and is only valid  until the next call to
- *   Dart_ExitScope.
- * \param size Returns the size of the buffer.
- * \return Returns an valid handle upon success.
- */
-DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle
-Dart_SaveTypeFeedback(uint8_t** buffer, intptr_t* buffer_length);
-
-/**
- * Compile functions using data from Dart_SaveTypeFeedback. The data must from a
- * VM with the same version and compiler flags.
- *
- * \return Returns an error handle if a compilation error was encountered or a
- *   version mismatch is detected.
- */
-DART_EXPORT DART_WARN_UNUSED_RESULT Dart_Handle
-Dart_LoadTypeFeedback(uint8_t* buffer, intptr_t buffer_length);
-
-/*
  * ==============
  * Precompilation
  * ==============
diff --git a/runtime/tests/vm/dart/compilation_trace_test.dart b/runtime/tests/vm/dart/compilation_trace_test.dart
deleted file mode 100644
index 4ebafb5..0000000
--- a/runtime/tests/vm/dart/compilation_trace_test.dart
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import "dart:async";
-import "dart:io";
-
-import "package:path/path.dart" as p;
-
-import "snapshot_test_helper.dart";
-
-int fib(int n) {
-  if (n <= 1) return 1;
-  return fib(n - 1) + fib(n - 2);
-}
-
-Future<void> main(List<String> args) async {
-  if (args.contains("--child")) {
-    print(fib(35));
-    return;
-  }
-
-  if (!Platform.script.toString().endsWith(".dart")) {
-    print("This test must run from source");
-    return;
-  }
-
-  await withTempDir((String tmp) async {
-    final String tracePath = p.join(tmp, "compilation_trace.txt");
-
-    final result1 = await runDart("generate compilation trace", [
-      "--save_compilation_trace=$tracePath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result1);
-
-    final result2 = await runDart("use compilation trace", [
-      "--load_compilation_trace=$tracePath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result2);
-  });
-}
diff --git a/runtime/tests/vm/dart/type_feedback_test.dart b/runtime/tests/vm/dart/type_feedback_test.dart
deleted file mode 100644
index 6211c70..0000000
--- a/runtime/tests/vm/dart/type_feedback_test.dart
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import "dart:async";
-import "dart:io";
-
-import "package:path/path.dart" as p;
-
-import "snapshot_test_helper.dart";
-
-int fib(int n) {
-  if (n <= 1) return 1;
-  return fib(n - 1) + fib(n - 2);
-}
-
-Future<void> main(List<String> args) async {
-  if (args.contains("--child")) {
-    print(fib(35));
-    return;
-  }
-
-  if (!Platform.script.toString().endsWith(".dart")) {
-    print("This test must run from source");
-    return;
-  }
-
-  await withTempDir((String tmp) async {
-    final String feedbackPath = p.join(tmp, "type_feedback.bin");
-
-    final result1 = await runDart("generate type feedback", [
-      "--save_type_feedback=$feedbackPath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result1);
-
-    final result2 = await runDart("use type feedback", [
-      "--load_type_feedback=$feedbackPath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result2);
-  });
-}
diff --git a/runtime/tests/vm/dart_2/compilation_trace_test.dart b/runtime/tests/vm/dart_2/compilation_trace_test.dart
deleted file mode 100644
index 4ebafb5..0000000
--- a/runtime/tests/vm/dart_2/compilation_trace_test.dart
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import "dart:async";
-import "dart:io";
-
-import "package:path/path.dart" as p;
-
-import "snapshot_test_helper.dart";
-
-int fib(int n) {
-  if (n <= 1) return 1;
-  return fib(n - 1) + fib(n - 2);
-}
-
-Future<void> main(List<String> args) async {
-  if (args.contains("--child")) {
-    print(fib(35));
-    return;
-  }
-
-  if (!Platform.script.toString().endsWith(".dart")) {
-    print("This test must run from source");
-    return;
-  }
-
-  await withTempDir((String tmp) async {
-    final String tracePath = p.join(tmp, "compilation_trace.txt");
-
-    final result1 = await runDart("generate compilation trace", [
-      "--save_compilation_trace=$tracePath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result1);
-
-    final result2 = await runDart("use compilation trace", [
-      "--load_compilation_trace=$tracePath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result2);
-  });
-}
diff --git a/runtime/tests/vm/dart_2/type_feedback_test.dart b/runtime/tests/vm/dart_2/type_feedback_test.dart
deleted file mode 100644
index 6211c70..0000000
--- a/runtime/tests/vm/dart_2/type_feedback_test.dart
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-import "dart:async";
-import "dart:io";
-
-import "package:path/path.dart" as p;
-
-import "snapshot_test_helper.dart";
-
-int fib(int n) {
-  if (n <= 1) return 1;
-  return fib(n - 1) + fib(n - 2);
-}
-
-Future<void> main(List<String> args) async {
-  if (args.contains("--child")) {
-    print(fib(35));
-    return;
-  }
-
-  if (!Platform.script.toString().endsWith(".dart")) {
-    print("This test must run from source");
-    return;
-  }
-
-  await withTempDir((String tmp) async {
-    final String feedbackPath = p.join(tmp, "type_feedback.bin");
-
-    final result1 = await runDart("generate type feedback", [
-      "--save_type_feedback=$feedbackPath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result1);
-
-    final result2 = await runDart("use type feedback", [
-      "--load_type_feedback=$feedbackPath",
-      Platform.script.toFilePath(),
-      "--child",
-    ]);
-    expectOutput("14930352", result2);
-  });
-}
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index 653d67a..45d402d 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -460,7 +460,6 @@
 
 [ $hot_reload || $hot_reload_rollback ]
 dart/appjit*: SkipByDesign # Cannot reload with URI pointing to app snapshot.
-dart/compilation_trace_test: Pass, Slow
 dart/disassemble_determinism_test: SkipSlow # Runs expensive fibonacci(32) computation in 2 subprocesses
 dart/isolates/spawn_function_test: Skip # This test explicitly enables isolate groups (off-by-default atm). It will be enabled once full IG reloading is implemented.
 dart/issue_31959_31960_test: SkipSlow
@@ -472,9 +471,7 @@
 dart/spawn_shutdown_test: Skip # We can shutdown an isolate before it reloads.
 dart/splay_test: SkipSlow
 dart/stack_overflow_shared_test: SkipSlow # Too slow with --shared-slow-path-triggers-gc flag and not relevant outside precompiled.
-dart/type_feedback_test: Pass, Slow
 dart_2/appjit*: SkipByDesign # Cannot reload with URI pointing to app snapshot.
-dart_2/compilation_trace_test: Pass, Slow
 dart_2/disassemble_determinism_test: SkipSlow # Runs expensive fibonacci(32) computation in 2 subprocesses
 dart_2/isolates/spawn_function_test: Skip # This test explicitly enables isolate groups (off-by-default atm). It will be enabled once full IG reloading is implemented.
 dart_2/issue_31959_31960_test: SkipSlow
@@ -486,7 +483,6 @@
 dart_2/spawn_shutdown_test: Skip # We can shutdown an isolate before it reloads.
 dart_2/splay_test: SkipSlow
 dart_2/stack_overflow_shared_test: SkipSlow # Too slow with --shared-slow-path-triggers-gc flag and not relevant outside precompiled.
-dart_2/type_feedback_test: Pass, Slow
 
 [ $hot_reload || $hot_reload_rollback || $compiler != dartk && $compiler != dartkp ]
 dart/entrypoints/*: SkipByDesign # These tests are for compiler optimizations and very sensitive to when functions are optimized, so they are disabled on hotreload and optcounter bots.
diff --git a/runtime/tools/create_snapshot_bin.py b/runtime/tools/create_snapshot_bin.py
index 65c35a8..10519b2 100755
--- a/runtime/tools/create_snapshot_bin.py
+++ b/runtime/tools/create_snapshot_bin.py
@@ -27,13 +27,6 @@
         help="kind of snapshot to generate",
         default="core")
     result.add_option(
-        "--load_compilation_trace",
-        action="store",
-        type="string",
-        help=
-        "path to a compilation trace to load before generating a core-jit snapshot"
-    )
-    result.add_option(
         "--vm_flag",
         action="append",
         type="string",
@@ -139,10 +132,6 @@
     for flag in options.vm_flag:
         script_args.append(flag)
 
-    if options.load_compilation_trace:
-        script_args.append(''.join(
-            ["--load_compilation_trace=", options.load_compilation_trace]))
-
     # Pass along the packages if there is one.
     if options.packages:
         script_args.append(''.join(["--packages=", options.packages]))
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 9040385..99f2596 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -5560,6 +5560,7 @@
         *code ^= d->ReadRef();
         StubCode::EntryAtPut(i, code);
       }
+      StubCode::InitializationDone();
     }
   }
 
diff --git a/runtime/vm/compilation_trace.cc b/runtime/vm/compilation_trace.cc
deleted file mode 100644
index 7afcf22..0000000
--- a/runtime/vm/compilation_trace.cc
+++ /dev/null
@@ -1,1028 +0,0 @@
-// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#include "vm/compilation_trace.h"
-
-#include "vm/closure_functions_cache.h"
-#include "vm/compiler/jit/compiler.h"
-#include "vm/globals.h"
-#include "vm/log.h"
-#include "vm/longjump.h"
-#include "vm/object_store.h"
-#include "vm/resolver.h"
-#include "vm/symbols.h"
-#include "vm/version.h"
-
-namespace dart {
-
-#if !defined(DART_PRECOMPILED_RUNTIME)
-
-DEFINE_FLAG(bool, trace_compilation_trace, false, "Trace compilation trace.");
-
-CompilationTraceSaver::CompilationTraceSaver(Zone* zone)
-    : buf_(zone, 1 * MB),
-      func_name_(String::Handle(zone)),
-      cls_(Class::Handle(zone)),
-      cls_name_(String::Handle(zone)),
-      lib_(Library::Handle(zone)),
-      uri_(String::Handle(zone)) {}
-
-void CompilationTraceSaver::VisitFunction(const Function& function) {
-  if (!function.HasCode()) {
-    return;  // Not compiled.
-  }
-  if (function.parent_function() != Function::null()) {
-    // Lookup works poorly for local functions. We compile all local functions
-    // in a compiled function instead.
-    return;
-  }
-
-  func_name_ = function.name();
-  func_name_ = String::RemovePrivateKey(func_name_);
-  cls_ = function.Owner();
-  cls_name_ = cls_.Name();
-  cls_name_ = String::RemovePrivateKey(cls_name_);
-  lib_ = cls_.library();
-  uri_ = lib_.url();
-  buf_.Printf("%s,%s,%s\n", uri_.ToCString(), cls_name_.ToCString(),
-              func_name_.ToCString());
-}
-
-CompilationTraceLoader::CompilationTraceLoader(Thread* thread)
-    : thread_(thread),
-      zone_(thread->zone()),
-      uri_(String::Handle(zone_)),
-      class_name_(String::Handle(zone_)),
-      function_name_(String::Handle(zone_)),
-      function_name2_(String::Handle(zone_)),
-      lib_(Library::Handle(zone_)),
-      cls_(Class::Handle(zone_)),
-      function_(Function::Handle(zone_)),
-      function2_(Function::Handle(zone_)),
-      field_(Field::Handle(zone_)),
-      sites_(Array::Handle(zone_)),
-      site_(ICData::Handle(zone_)),
-      static_type_(AbstractType::Handle(zone_)),
-      receiver_cls_(Class::Handle(zone_)),
-      target_(Function::Handle(zone_)),
-      selector_(String::Handle(zone_)),
-      args_desc_(Array::Handle(zone_)),
-      error_(Object::Handle(zone_)) {}
-
-static char* FindCharacter(char* str, char goal, char* limit) {
-  while (str < limit) {
-    if (*str == goal) {
-      return str;
-    }
-    str++;
-  }
-  return NULL;
-}
-
-ObjectPtr CompilationTraceLoader::CompileTrace(uint8_t* buffer, intptr_t size) {
-  // First compile functions named in the trace.
-  char* cursor = reinterpret_cast<char*>(buffer);
-  char* limit = cursor + size;
-  while (cursor < limit) {
-    char* uri = cursor;
-    char* comma1 = FindCharacter(uri, ',', limit);
-    if (comma1 == NULL) {
-      break;
-    }
-    *comma1 = 0;
-    char* cls_name = comma1 + 1;
-    char* comma2 = FindCharacter(cls_name, ',', limit);
-    if (comma2 == NULL) {
-      break;
-    }
-    *comma2 = 0;
-    char* func_name = comma2 + 1;
-    char* newline = FindCharacter(func_name, '\n', limit);
-    if (newline == NULL) {
-      break;
-    }
-    *newline = 0;
-    error_ = CompileTriple(uri, cls_name, func_name);
-    if (error_.IsError()) {
-      return error_.ptr();
-    }
-    cursor = newline + 1;
-  }
-
-  // Next, compile common dispatchers. These aren't found with the normal
-  // lookup above because they have irregular lookup that depends on the
-  // arguments descriptor (e.g. call() versus call(x)).
-  const Class& closure_class = Class::Handle(
-      zone_, thread_->isolate_group()->object_store()->closure_class());
-  Array& arguments_descriptor = Array::Handle(zone_);
-  Function& dispatcher = Function::Handle(zone_);
-  for (intptr_t argc = 1; argc <= 4; argc++) {
-    const intptr_t kTypeArgsLen = 0;
-
-    // TODO(dartbug.com/33549): Update this code to use the size of the
-    // parameters when supporting calls to closures with unboxed parameters.
-    arguments_descriptor = ArgumentsDescriptor::NewBoxed(kTypeArgsLen, argc);
-    dispatcher = closure_class.GetInvocationDispatcher(
-        Symbols::Call(), arguments_descriptor,
-        UntaggedFunction::kInvokeFieldDispatcher, true /* create_if_absent */);
-    error_ = CompileFunction(dispatcher);
-    if (error_.IsError()) {
-      return error_.ptr();
-    }
-  }
-
-  // Finally, compile closures in all compiled functions. Note: We rely on the
-  // fact that parent functions are visited before children.
-  error_ = Object::null();
-  auto& result = Object::Handle(zone_);
-  ClosureFunctionsCache::ForAllClosureFunctions([&](const Function& func) {
-    function2_ = func.parent_function();
-    if (function2_.HasCode()) {
-      result = CompileFunction(function_);
-      if (result.IsError()) {
-        error_ = result.ptr();
-        return false;  // Stop iteration.
-      }
-    }
-    return true;
-  });
-
-  return Object::null();
-}
-
-// Use a fuzzy match to find the right function to compile. This allows a
-// compilation trace to remain mostly valid in the face of program changes, and
-// deals with implicit/dispatcher functions that don't have proper names.
-//  - Ignore private name mangling
-//  - If looking for a getter and we only have the corresponding regular method,
-//    compile the regular method, create its implicit closure and compile that.
-//  - If looking for a regular method and we only have the corresponding getter,
-//    compile the getter, create its method extractor and compile that.
-//  - If looking for a getter and we only have a const field, evaluate the const
-//    field.
-ObjectPtr CompilationTraceLoader::CompileTriple(const char* uri_cstr,
-                                                const char* cls_cstr,
-                                                const char* func_cstr) {
-  uri_ = Symbols::New(thread_, uri_cstr);
-  class_name_ = Symbols::New(thread_, cls_cstr);
-  function_name_ = Symbols::New(thread_, func_cstr);
-
-  if (function_name_.Equals("_getMainClosure")) {
-    // The scheme for invoking main relies on compiling _getMainClosure after
-    // synthetically importing the root library.
-    if (FLAG_trace_compilation_trace) {
-      THR_Print("Compilation trace: skip %s,%s,%s\n", uri_.ToCString(),
-                class_name_.ToCString(), function_name_.ToCString());
-    }
-    return Object::null();
-  }
-
-  lib_ = Library::LookupLibrary(thread_, uri_);
-  if (lib_.IsNull()) {
-    // Missing library.
-    if (FLAG_trace_compilation_trace) {
-      THR_Print("Compilation trace: missing library %s,%s,%s\n",
-                uri_.ToCString(), class_name_.ToCString(),
-                function_name_.ToCString());
-    }
-    return Object::null();
-  }
-
-  bool is_dyn = Function::IsDynamicInvocationForwarderName(function_name_);
-  if (is_dyn) {
-    function_name_ =
-        Function::DemangleDynamicInvocationForwarderName(function_name_);
-  }
-
-  bool is_getter = Field::IsGetterName(function_name_);
-  bool is_init = Field::IsInitName(function_name_);
-  bool add_closure = false;
-  bool processed = false;
-
-  if (class_name_.Equals(Symbols::TopLevel())) {
-    function_ = lib_.LookupFunctionAllowPrivate(function_name_);
-    field_ = lib_.LookupFieldAllowPrivate(function_name_);
-    if (function_.IsNull() && is_getter) {
-      // Maybe this was a tear off.
-      add_closure = true;
-      function_name2_ = Field::NameFromGetter(function_name_);
-      function_ = lib_.LookupFunctionAllowPrivate(function_name2_);
-      field_ = lib_.LookupFieldAllowPrivate(function_name2_);
-    }
-    if (field_.IsNull() && is_getter) {
-      function_name2_ = Field::NameFromGetter(function_name_);
-      field_ = lib_.LookupFieldAllowPrivate(function_name2_);
-    }
-    if (field_.IsNull() && is_init) {
-      function_name2_ = Field::NameFromInit(function_name_);
-      field_ = lib_.LookupFieldAllowPrivate(function_name2_);
-    }
-  } else {
-    cls_ = lib_.SlowLookupClassAllowMultiPartPrivate(class_name_);
-    if (cls_.IsNull()) {
-      // Missing class.
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Compilation trace: missing class %s,%s,%s\n",
-                  uri_.ToCString(), class_name_.ToCString(),
-                  function_name_.ToCString());
-      }
-      return Object::null();
-    }
-
-    error_ = cls_.EnsureIsFinalized(thread_);
-    if (error_.IsError()) {
-      // Non-finalized class.
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Compilation trace: non-finalized class %s,%s,%s (%s)\n",
-                  uri_.ToCString(), class_name_.ToCString(),
-                  function_name_.ToCString(),
-                  Error::Cast(error_).ToErrorCString());
-      }
-      return error_.ptr();
-    }
-
-    function_ = cls_.LookupFunctionAllowPrivate(function_name_);
-    field_ = cls_.LookupFieldAllowPrivate(function_name_);
-    if (function_.IsNull() && is_getter) {
-      // Maybe this was a tear off.
-      add_closure = true;
-      function_name2_ = Field::NameFromGetter(function_name_);
-      function_ = cls_.LookupFunctionAllowPrivate(function_name2_);
-      field_ = cls_.LookupFieldAllowPrivate(function_name2_);
-      if (!function_.IsNull() && !function_.is_static()) {
-        // Maybe this was a method extractor.
-        function2_ =
-            Resolver::ResolveDynamicAnyArgs(zone_, cls_, function_name_);
-        if (!function2_.IsNull()) {
-          error_ = CompileFunction(function2_);
-          if (error_.IsError()) {
-            if (FLAG_trace_compilation_trace) {
-              THR_Print(
-                  "Compilation trace: error compiling extractor %s for "
-                  "%s,%s,%s (%s)\n",
-                  function2_.ToCString(), uri_.ToCString(),
-                  class_name_.ToCString(), function_name_.ToCString(),
-                  Error::Cast(error_).ToErrorCString());
-            }
-            return error_.ptr();
-          }
-        }
-      }
-    }
-    if (field_.IsNull() && is_getter) {
-      function_name2_ = Field::NameFromGetter(function_name_);
-      field_ = cls_.LookupFieldAllowPrivate(function_name2_);
-    }
-    if (field_.IsNull() && is_init) {
-      function_name2_ = Field::NameFromInit(function_name_);
-      field_ = cls_.LookupFieldAllowPrivate(function_name2_);
-    }
-  }
-
-  if (!field_.IsNull() && field_.is_const() && field_.is_static() &&
-      (field_.StaticValue() == Object::sentinel().ptr())) {
-    processed = true;
-    error_ = field_.InitializeStatic();
-    if (error_.IsError()) {
-      if (FLAG_trace_compilation_trace) {
-        THR_Print(
-            "Compilation trace: error initializing field %s for %s,%s,%s "
-            "(%s)\n",
-            field_.ToCString(), uri_.ToCString(), class_name_.ToCString(),
-            function_name_.ToCString(), Error::Cast(error_).ToErrorCString());
-      }
-      return error_.ptr();
-    }
-  }
-
-  if (!function_.IsNull()) {
-    processed = true;
-    error_ = CompileFunction(function_);
-    if (error_.IsError()) {
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Compilation trace: error compiling %s,%s,%s (%s)\n",
-                  uri_.ToCString(), class_name_.ToCString(),
-                  function_name_.ToCString(),
-                  Error::Cast(error_).ToErrorCString());
-      }
-      return error_.ptr();
-    }
-    if (add_closure) {
-      function_ = function_.ImplicitClosureFunction();
-      error_ = CompileFunction(function_);
-      if (error_.IsError()) {
-        if (FLAG_trace_compilation_trace) {
-          THR_Print(
-              "Compilation trace: error compiling closure %s,%s,%s (%s)\n",
-              uri_.ToCString(), class_name_.ToCString(),
-              function_name_.ToCString(), Error::Cast(error_).ToErrorCString());
-        }
-        return error_.ptr();
-      }
-    } else if (is_dyn) {
-      function_name_ = function_.name();  // With private mangling.
-      function_name_ =
-          Function::CreateDynamicInvocationForwarderName(function_name_);
-      function_ = function_.GetDynamicInvocationForwarder(function_name_);
-      error_ = CompileFunction(function_);
-      if (error_.IsError()) {
-        if (FLAG_trace_compilation_trace) {
-          THR_Print(
-              "Compilation trace: error compiling dynamic forwarder %s,%s,%s "
-              "(%s)\n",
-              uri_.ToCString(), class_name_.ToCString(),
-              function_name_.ToCString(), Error::Cast(error_).ToErrorCString());
-        }
-        return error_.ptr();
-      }
-    }
-  }
-
-  if (!field_.IsNull() && field_.is_static() && !field_.is_const() &&
-      field_.has_nontrivial_initializer()) {
-    processed = true;
-    function_ = field_.EnsureInitializerFunction();
-    error_ = CompileFunction(function_);
-    if (error_.IsError()) {
-      if (FLAG_trace_compilation_trace) {
-        THR_Print(
-            "Compilation trace: error compiling initializer %s,%s,%s (%s)\n",
-            uri_.ToCString(), class_name_.ToCString(),
-            function_name_.ToCString(), Error::Cast(error_).ToErrorCString());
-      }
-      return error_.ptr();
-    }
-  }
-
-  if (FLAG_trace_compilation_trace) {
-    if (!processed) {
-      THR_Print("Compilation trace: ignored %s,%s,%s\n", uri_.ToCString(),
-                class_name_.ToCString(), function_name_.ToCString());
-    }
-  }
-  return Object::null();
-}
-
-ObjectPtr CompilationTraceLoader::CompileFunction(const Function& function) {
-  if (function.is_abstract() || function.HasCode()) {
-    return Object::null();
-  }
-
-  error_ = Compiler::CompileFunction(thread_, function);
-  if (error_.IsError()) {
-    return error_.ptr();
-  }
-
-  SpeculateInstanceCallTargets(function);
-
-  return error_.ptr();
-}
-
-// For instance calls, if the receiver's static type has one concrete
-// implementation, lookup the target for that implementation and add it
-// to the ICData's entries.
-// For some well-known interfaces, do the same for the most common concrete
-// implementation (e.g., int -> _Smi).
-void CompilationTraceLoader::SpeculateInstanceCallTargets(
-    const Function& function) {
-  sites_ = function.ic_data_array();
-  if (sites_.IsNull()) {
-    return;
-  }
-  for (intptr_t i = 1; i < sites_.Length(); i++) {
-    site_ ^= sites_.At(i);
-    if (site_.rebind_rule() != ICData::kInstance) {
-      continue;
-    }
-    if (site_.NumArgsTested() != 1) {
-      continue;
-    }
-
-    static_type_ = site_.receivers_static_type();
-    if (static_type_.IsNull()) {
-      continue;
-    } else if (static_type_.IsDoubleType()) {
-      receiver_cls_ = IsolateGroup::Current()->class_table()->At(kDoubleCid);
-    } else if (static_type_.IsIntType()) {
-      receiver_cls_ = IsolateGroup::Current()->class_table()->At(kSmiCid);
-    } else if (static_type_.IsStringType()) {
-      receiver_cls_ =
-          IsolateGroup::Current()->class_table()->At(kOneByteStringCid);
-    } else if (static_type_.IsDartFunctionType() ||
-               static_type_.IsDartClosureType()) {
-      receiver_cls_ = IsolateGroup::Current()->class_table()->At(kClosureCid);
-    } else if (static_type_.HasTypeClass()) {
-      receiver_cls_ = static_type_.type_class();
-      if (receiver_cls_.is_implemented() || receiver_cls_.is_abstract()) {
-        continue;
-      }
-    } else {
-      continue;
-    }
-
-    selector_ = site_.target_name();
-    args_desc_ = site_.arguments_descriptor();
-    target_ = Resolver::ResolveDynamicForReceiverClass(
-        receiver_cls_, selector_, ArgumentsDescriptor(args_desc_));
-    if (!target_.IsNull() && !site_.HasReceiverClassId(receiver_cls_.id())) {
-      intptr_t count = 0;  // Don't pollute type feedback and coverage data.
-      site_.AddReceiverCheck(receiver_cls_.id(), target_, count);
-    }
-  }
-}
-
-TypeFeedbackSaver::TypeFeedbackSaver(BaseWriteStream* stream)
-    : stream_(stream),
-      cls_(Class::Handle()),
-      lib_(Library::Handle()),
-      str_(String::Handle()),
-      fields_(Array::Handle()),
-      field_(Field::Handle()),
-      code_(Code::Handle()),
-      call_sites_(Array::Handle()),
-      call_site_(ICData::Handle()) {}
-
-// These flags affect deopt ids.
-static char* CompilerFlags() {
-  TextBuffer buffer(64);
-
-#define ADD_FLAG(flag) buffer.AddString(FLAG_##flag ? " " #flag : " no-" #flag)
-  ADD_FLAG(enable_asserts);
-  ADD_FLAG(use_field_guards);
-  ADD_FLAG(use_osr);
-  ADD_FLAG(fields_may_be_reset);
-#undef ADD_FLAG
-
-  return buffer.Steal();
-}
-
-void TypeFeedbackSaver::WriteHeader() {
-  const char* expected_version = Version::SnapshotString();
-  ASSERT(expected_version != NULL);
-  const intptr_t version_len = strlen(expected_version);
-  stream_->WriteBytes(reinterpret_cast<const uint8_t*>(expected_version),
-                      version_len);
-
-  char* expected_features = CompilerFlags();
-  ASSERT(expected_features != NULL);
-  const intptr_t features_len = strlen(expected_features);
-  stream_->WriteBytes(reinterpret_cast<const uint8_t*>(expected_features),
-                      features_len + 1);
-  free(expected_features);
-}
-
-void TypeFeedbackSaver::SaveClasses() {
-  ClassTable* table = IsolateGroup::Current()->class_table();
-
-  intptr_t num_cids = table->NumCids();
-  WriteInt(num_cids);
-
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
-    cls_ = table->At(cid);
-    WriteClassByName(cls_);
-  }
-}
-
-void TypeFeedbackSaver::SaveFields() {
-  ClassTable* table = IsolateGroup::Current()->class_table();
-  intptr_t num_cids = table->NumCids();
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
-    cls_ = table->At(cid);
-    WriteClassByName(cls_);
-
-    fields_ = cls_.fields();
-    WriteInt(fields_.Length());
-    for (intptr_t i = 0; i < fields_.Length(); i++) {
-      field_ ^= fields_.At(i);
-
-      str_ = field_.name();
-      str_ = String::RemovePrivateKey(str_);
-      WriteString(str_);
-
-      WriteInt(field_.guarded_cid());
-      WriteInt(static_cast<intptr_t>(field_.is_nullable()));
-    }
-  }
-}
-
-void TypeFeedbackSaver::VisitFunction(const Function& function) {
-  if (!function.HasCode()) {
-    return;  // Not compiled.
-  }
-
-  cls_ = function.Owner();
-  WriteClassByName(cls_);
-
-  str_ = function.name();
-  str_ = String::RemovePrivateKey(str_);
-  WriteString(str_);
-
-  WriteInt(function.kind());
-  WriteInt(function.token_pos().Serialize());
-
-  code_ = function.CurrentCode();
-  intptr_t usage = function.usage_counter();
-  if (usage < 0) {
-    // Usage is set to INT32_MIN while in the background compilation queue ...
-    usage = (usage - INT32_MIN) + FLAG_optimization_counter_threshold;
-  } else if (code_.is_optimized()) {
-    // ... and set to 0 when an optimizing compile completes.
-    usage = usage + FLAG_optimization_counter_threshold;
-  }
-  WriteInt(usage);
-
-  WriteInt(function.inlining_depth());
-
-  call_sites_ = function.ic_data_array();
-  if (call_sites_.IsNull()) {
-    call_sites_ = Object::empty_array().ptr();  // Remove edge case.
-  }
-
-  // First element is edge counters.
-  WriteInt(call_sites_.Length() - 1);
-  for (intptr_t i = 1; i < call_sites_.Length(); i++) {
-    call_site_ ^= call_sites_.At(i);
-
-    WriteInt(call_site_.deopt_id());
-    WriteInt(call_site_.rebind_rule());
-
-    str_ = call_site_.target_name();
-    str_ = String::RemovePrivateKey(str_);
-    WriteString(str_);
-
-    intptr_t num_checked_arguments = call_site_.NumArgsTested();
-    WriteInt(num_checked_arguments);
-
-    intptr_t num_entries = call_site_.NumberOfChecks();
-    WriteInt(num_entries);
-
-    for (intptr_t entry_index = 0; entry_index < num_entries; entry_index++) {
-      WriteInt(call_site_.GetCountAt(entry_index));
-
-      for (intptr_t argument_index = 0; argument_index < num_checked_arguments;
-           argument_index++) {
-        WriteInt(call_site_.GetClassIdAt(entry_index, argument_index));
-      }
-    }
-  }
-}
-
-void TypeFeedbackSaver::WriteClassByName(const Class& cls) {
-  lib_ = cls.library();
-
-  str_ = lib_.url();
-  WriteString(str_);
-
-  str_ = cls_.Name();
-  str_ = String::RemovePrivateKey(str_);
-  WriteString(str_);
-}
-
-void TypeFeedbackSaver::WriteString(const String& value) {
-  const char* cstr = value.ToCString();
-  intptr_t len = strlen(cstr);
-  stream_->WriteUnsigned(len);
-  stream_->WriteBytes(cstr, len);
-}
-
-TypeFeedbackLoader::TypeFeedbackLoader(Thread* thread)
-    : thread_(thread),
-      zone_(thread->zone()),
-      stream_(nullptr),
-      cid_map_(nullptr),
-      uri_(String::Handle(zone_)),
-      lib_(Library::Handle(zone_)),
-      cls_name_(String::Handle(zone_)),
-      cls_(Class::Handle(zone_)),
-      field_name_(String::Handle(zone_)),
-      fields_(Array::Handle(zone_)),
-      field_(Field::Handle(zone_)),
-      func_name_(String::Handle(zone_)),
-      func_(Function::Handle(zone_)),
-      call_sites_(Array::Handle(zone_)),
-      call_site_(ICData::Handle(zone_)),
-      target_name_(String::Handle(zone_)),
-      target_(Function::Handle(zone_)),
-      args_desc_(Array::Handle(zone_)),
-      functions_to_compile_(
-          GrowableObjectArray::Handle(zone_, GrowableObjectArray::New())),
-      error_(Error::Handle(zone_)) {}
-
-TypeFeedbackLoader::~TypeFeedbackLoader() {
-  delete[] cid_map_;
-}
-
-ObjectPtr TypeFeedbackLoader::LoadFeedback(ReadStream* stream) {
-  stream_ = stream;
-
-  error_ = CheckHeader();
-  if (error_.IsError()) {
-    return error_.ptr();
-  }
-
-  error_ = LoadClasses();
-  if (error_.IsError()) {
-    return error_.ptr();
-  }
-
-  error_ = LoadFields();
-  if (error_.IsError()) {
-    return error_.ptr();
-  }
-
-  while (stream_->PendingBytes() > 0) {
-    error_ = LoadFunction();
-    if (error_.IsError()) {
-      return error_.ptr();
-    }
-  }
-
-  while (functions_to_compile_.Length() > 0) {
-    func_ ^= functions_to_compile_.RemoveLast();
-
-    if (Compiler::CanOptimizeFunction(thread_, func_) &&
-        (func_.usage_counter() >= FLAG_optimization_counter_threshold)) {
-      error_ = Compiler::CompileOptimizedFunction(thread_, func_);
-      if (error_.IsError()) {
-        return error_.ptr();
-      }
-    }
-  }
-
-  if (FLAG_trace_compilation_trace) {
-    THR_Print("Done loading feedback\n");
-  }
-
-  return Error::null();
-}
-
-ObjectPtr TypeFeedbackLoader::CheckHeader() {
-  const char* expected_version = Version::SnapshotString();
-  ASSERT(expected_version != NULL);
-  const intptr_t version_len = strlen(expected_version);
-  if (stream_->PendingBytes() < version_len) {
-    const intptr_t kMessageBufferSize = 128;
-    char message_buffer[kMessageBufferSize];
-    Utils::SNPrint(message_buffer, kMessageBufferSize,
-                   "No snapshot version found, expected '%s'",
-                   expected_version);
-    const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
-    return ApiError::New(msg, Heap::kOld);
-  }
-
-  const char* version =
-      reinterpret_cast<const char*>(stream_->AddressOfCurrentPosition());
-  ASSERT(version != NULL);
-  if (strncmp(version, expected_version, version_len) != 0) {
-    const intptr_t kMessageBufferSize = 256;
-    char message_buffer[kMessageBufferSize];
-    char* actual_version = Utils::StrNDup(version, version_len);
-    Utils::SNPrint(message_buffer, kMessageBufferSize,
-                   "Wrong snapshot version, expected '%s' found '%s'",
-                   expected_version, actual_version);
-    free(actual_version);
-    const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
-    return ApiError::New(msg, Heap::kOld);
-  }
-  stream_->Advance(version_len);
-
-  char* expected_features = CompilerFlags();
-  ASSERT(expected_features != NULL);
-  const intptr_t expected_len = strlen(expected_features);
-
-  const char* features =
-      reinterpret_cast<const char*>(stream_->AddressOfCurrentPosition());
-  ASSERT(features != NULL);
-  intptr_t buffer_len = Utils::StrNLen(features, stream_->PendingBytes());
-  if ((buffer_len != expected_len) ||
-      (strncmp(features, expected_features, expected_len) != 0)) {
-    const String& msg = String::Handle(String::NewFormatted(
-        Heap::kOld,
-        "Feedback not compatible with the current VM configuration: "
-        "the feedback requires '%.*s' but the VM has '%s'",
-        static_cast<int>(buffer_len > 1024 ? 1024 : buffer_len), features,
-        expected_features));
-    free(expected_features);
-    return ApiError::New(msg, Heap::kOld);
-  }
-  free(expected_features);
-  stream_->Advance(expected_len + 1);
-  return Error::null();
-}
-
-ObjectPtr TypeFeedbackLoader::LoadClasses() {
-  num_cids_ = ReadInt();
-
-  cid_map_ = new intptr_t[num_cids_];
-  for (intptr_t cid = 0; cid < num_cids_; cid++) {
-    cid_map_[cid] = kIllegalCid;
-  }
-  for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
-    cid_map_[cid] = cid;
-  }
-
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids_; cid++) {
-    cls_ = ReadClassByName();
-    if (!cls_.IsNull()) {
-      cid_map_[cid] = cls_.id();
-    }
-  }
-
-  return Error::null();
-}
-
-ObjectPtr TypeFeedbackLoader::LoadFields() {
-  for (intptr_t cid = kNumPredefinedCids; cid < num_cids_; cid++) {
-    cls_ = ReadClassByName();
-    bool skip = cls_.IsNull();
-
-    intptr_t num_fields = ReadInt();
-    if (!skip && (num_fields > 0)) {
-      error_ = cls_.EnsureIsFinalized(thread_);
-      if (error_.IsError()) {
-        return error_.ptr();
-      }
-      fields_ = cls_.fields();
-    }
-
-    SafepointWriteRwLocker ml(thread_,
-                              thread_->isolate_group()->program_lock());
-    for (intptr_t i = 0; i < num_fields; i++) {
-      field_name_ = ReadString();
-      intptr_t guarded_cid = cid_map_[ReadInt()];
-      intptr_t is_nullable = ReadInt();
-
-      if (skip) {
-        continue;
-      }
-
-      if (i >= fields_.Length()) {
-        if (FLAG_trace_compilation_trace) {
-          THR_Print("Missing field %s\n", field_name_.ToCString());
-        }
-        continue;
-      }
-
-      field_ ^= fields_.At(i);
-      if (!String::EqualsIgnoringPrivateKey(String::Handle(field_.name()),
-                                            field_name_)) {
-        if (FLAG_trace_compilation_trace) {
-          THR_Print("Missing field %s\n", field_name_.ToCString());
-        }
-        continue;
-      }
-
-      if (guarded_cid == kIllegalCid) {
-        // Guarded CID from feedback is not in current program: assume the field
-        // will become polymorphic.
-        field_.set_guarded_cid(kDynamicCid);
-        field_.set_is_nullable(true);
-      } else if ((field_.guarded_cid() != kIllegalCid) &&
-                 (field_.guarded_cid() == guarded_cid)) {
-        // Guarded CID from feedback is different from initialized guarded CID
-        // in the current program: assume the field will become polymorphic.
-        field_.set_guarded_cid(kDynamicCid);
-        field_.set_is_nullable(true);
-      } else {
-        field_.set_guarded_cid(guarded_cid);
-        field_.set_is_nullable((is_nullable != 0) || field_.is_nullable());
-      }
-
-      // TODO(rmacnak): Merge other field type feedback.
-      field_.set_guarded_list_length(Field::kNoFixedLength);
-      field_.set_guarded_list_length_in_object_offset(
-          Field::kUnknownLengthOffset);
-      field_.set_static_type_exactness_state(
-          StaticTypeExactnessState::NotTracking());
-      field_.DeoptimizeDependentCode();
-    }
-  }
-
-  return Error::null();
-}
-
-ObjectPtr TypeFeedbackLoader::LoadFunction() {
-  bool skip = false;
-
-  cls_ = ReadClassByName();
-  if (!cls_.IsNull()) {
-    error_ = cls_.EnsureIsFinalized(thread_);
-    if (error_.IsError()) {
-      return error_.ptr();
-    }
-  } else {
-    skip = true;
-  }
-
-  func_name_ = ReadString();  // Without private mangling.
-  UntaggedFunction::Kind kind = static_cast<UntaggedFunction::Kind>(ReadInt());
-  const TokenPosition& token_pos = TokenPosition::Deserialize(ReadInt());
-  intptr_t usage = ReadInt();
-  intptr_t inlining_depth = ReadInt();
-  intptr_t num_call_sites = ReadInt();
-
-  if (!skip) {
-    func_ = FindFunction(kind, token_pos);
-    if (func_.IsNull()) {
-      skip = true;
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Missing function %s %s\n", func_name_.ToCString(),
-                  Function::KindToCString(kind));
-      }
-    }
-  }
-
-  if (!skip) {
-    error_ = Compiler::CompileFunction(thread_, func_);
-    if (error_.IsError()) {
-      return error_.ptr();
-    }
-    call_sites_ = func_.ic_data_array();
-    if (call_sites_.IsNull()) {
-      call_sites_ = Object::empty_array().ptr();  // Remove edge case.
-    }
-    if (call_sites_.Length() != num_call_sites + 1) {
-      skip = true;
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Mismatched call site count %s %" Pd " %" Pd "\n",
-                  func_name_.ToCString(), call_sites_.Length(), num_call_sites);
-      }
-    }
-  }
-
-  // First element is edge counters.
-  for (intptr_t i = 1; i <= num_call_sites; i++) {
-    intptr_t deopt_id = ReadInt();
-    intptr_t rebind_rule = ReadInt();
-    target_name_ = ReadString();
-    intptr_t num_checked_arguments = ReadInt();
-    intptr_t num_entries = ReadInt();
-
-    if (!skip) {
-      call_site_ ^= call_sites_.At(i);
-      if ((call_site_.deopt_id() != deopt_id) ||
-          (call_site_.rebind_rule() != rebind_rule) ||
-          (call_site_.NumArgsTested() != num_checked_arguments)) {
-        skip = true;
-        if (FLAG_trace_compilation_trace) {
-          THR_Print("Mismatched call site %s\n", call_site_.ToCString());
-        }
-      }
-    }
-
-    for (intptr_t entry_index = 0; entry_index < num_entries; entry_index++) {
-      intptr_t entry_usage = ReadInt();
-      bool skip_entry = skip;
-      GrowableArray<intptr_t> cids(num_checked_arguments);
-
-      for (intptr_t argument_index = 0; argument_index < num_checked_arguments;
-           argument_index++) {
-        intptr_t cid = cid_map_[ReadInt()];
-        cids.Add(cid);
-        if (cid == kIllegalCid) {
-          // Alternative: switch to a sentinel value such as kDynamicCid and
-          // have the optimizer generate a megamorphic call.
-          skip_entry = true;
-        }
-      }
-
-      if (skip_entry) {
-        continue;
-      }
-
-      intptr_t reuse_index = call_site_.FindCheck(cids);
-      if (reuse_index == -1) {
-        cls_ = thread_->isolate_group()->class_table()->At(cids[0]);
-        // Use target name and args descriptor from the current program
-        // instead of saved feedback to get the correct private mangling and
-        // ensure no arity mismatch crashes.
-        target_name_ = call_site_.target_name();
-        args_desc_ = call_site_.arguments_descriptor();
-        if (cls_.EnsureIsFinalized(thread_) == Error::null()) {
-          target_ = Resolver::ResolveDynamicForReceiverClass(
-              cls_, target_name_, ArgumentsDescriptor(args_desc_));
-        }
-        if (!target_.IsNull()) {
-          if (num_checked_arguments == 1) {
-            call_site_.AddReceiverCheck(cids[0], target_, entry_usage);
-          } else {
-            call_site_.AddCheck(cids, target_, entry_usage);
-          }
-        }
-      } else {
-        call_site_.IncrementCountAt(reuse_index, entry_usage);
-      }
-    }
-  }
-
-  if (!skip) {
-    func_.set_usage_counter(usage);
-    func_.set_inlining_depth(inlining_depth);
-
-    // Delay compilation until all feedback is loaded so feedback is available
-    // for inlined functions.
-    functions_to_compile_.Add(func_);
-  }
-
-  return Error::null();
-}
-
-FunctionPtr TypeFeedbackLoader::FindFunction(UntaggedFunction::Kind kind,
-                                             const TokenPosition& token_pos) {
-  if (cls_name_.Equals(Symbols::TopLevel())) {
-    func_ = lib_.LookupFunctionAllowPrivate(func_name_);
-  } else {
-    func_ = cls_.LookupFunctionAllowPrivate(func_name_);
-  }
-
-  if (!func_.IsNull()) {
-    // Found regular method.
-  } else if (kind == UntaggedFunction::kMethodExtractor) {
-    ASSERT(Field::IsGetterName(func_name_));
-    // Without private mangling:
-    String& name = String::Handle(zone_, Field::NameFromGetter(func_name_));
-    func_ = cls_.LookupFunctionAllowPrivate(name);
-    if (!func_.IsNull() && func_.IsDynamicFunction()) {
-      name = func_.name();  // With private mangling.
-      name = Field::GetterName(name);
-      func_ = func_.GetMethodExtractor(name);
-    } else {
-      func_ = Function::null();
-    }
-  } else if (kind == UntaggedFunction::kDynamicInvocationForwarder) {
-    // Without private mangling:
-    String& name = String::Handle(
-        zone_, Function::DemangleDynamicInvocationForwarderName(func_name_));
-    func_ = cls_.LookupFunctionAllowPrivate(name);
-    if (!func_.IsNull() && func_.IsDynamicFunction()) {
-      name = func_.name();  // With private mangling.
-      name = Function::CreateDynamicInvocationForwarderName(name);
-      SafepointWriteRwLocker ml(thread_,
-                                thread_->isolate_group()->program_lock());
-      func_ = func_.CreateDynamicInvocationForwarder(name);
-    } else {
-      func_ = Function::null();
-    }
-  } else if (kind == UntaggedFunction::kClosureFunction) {
-    // Note this lookup relies on parent functions appearing before child
-    // functions in the serialized feedback, so the parent will have already
-    // been unoptimized compilated and the child function created and added to
-    // ObjectStore::closure_functions_.
-    func_ = ClosureFunctionsCache::LookupClosureFunction(cls_, token_pos);
-  } else {
-    // This leaves unhandled:
-    // - kInvokeFieldDispatcher (how to get a valid args descriptor?)
-    // - static field getters
-    // - static field initializers (not retained by the field object)
-  }
-
-  if (!func_.IsNull()) {
-    if (kind == UntaggedFunction::kImplicitClosureFunction) {
-      func_ = func_.ImplicitClosureFunction();
-    }
-    if (func_.is_abstract() || (func_.kind() != kind)) {
-      func_ = Function::null();
-    }
-  }
-
-  return func_.ptr();
-}
-
-ClassPtr TypeFeedbackLoader::ReadClassByName() {
-  uri_ = ReadString();
-  cls_name_ = ReadString();
-
-  lib_ = Library::LookupLibrary(thread_, uri_);
-  if (lib_.IsNull()) {
-    if (FLAG_trace_compilation_trace) {
-      THR_Print("Missing library %s\n", uri_.ToCString());
-    }
-    return Class::null();
-  }
-
-  if (cls_name_.Equals(Symbols::TopLevel())) {
-    cls_ = lib_.toplevel_class();
-  } else {
-    cls_ = lib_.SlowLookupClassAllowMultiPartPrivate(cls_name_);
-    if (cls_.IsNull()) {
-      if (FLAG_trace_compilation_trace) {
-        THR_Print("Missing class %s %s\n", uri_.ToCString(),
-                  cls_name_.ToCString());
-      }
-    }
-  }
-  return cls_.ptr();
-}
-
-StringPtr TypeFeedbackLoader::ReadString() {
-  intptr_t len = stream_->ReadUnsigned();
-  const char* cstr =
-      reinterpret_cast<const char*>(stream_->AddressOfCurrentPosition());
-  stream_->Advance(len);
-  return Symbols::New(thread_, cstr, len);
-}
-
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
-
-}  // namespace dart
diff --git a/runtime/vm/compilation_trace.h b/runtime/vm/compilation_trace.h
deleted file mode 100644
index 14996ec..0000000
--- a/runtime/vm/compilation_trace.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-#ifndef RUNTIME_VM_COMPILATION_TRACE_H_
-#define RUNTIME_VM_COMPILATION_TRACE_H_
-
-#include "platform/assert.h"
-#include "vm/object.h"
-#include "vm/program_visitor.h"
-#include "vm/zone_text_buffer.h"
-
-#if !defined(DART_PRECOMPILED_RUNTIME)
-
-namespace dart {
-
-class CompilationTraceSaver : public FunctionVisitor {
- public:
-  explicit CompilationTraceSaver(Zone* zone);
-  void VisitFunction(const Function& function);
-
-  void StealBuffer(uint8_t** buffer, intptr_t* buffer_length) {
-    *buffer = reinterpret_cast<uint8_t*>(buf_.buffer());
-    *buffer_length = buf_.length();
-  }
-
- private:
-  ZoneTextBuffer buf_;
-  String& func_name_;
-  Class& cls_;
-  String& cls_name_;
-  Library& lib_;
-  String& uri_;
-};
-
-class CompilationTraceLoader : public ValueObject {
- public:
-  explicit CompilationTraceLoader(Thread* thread);
-
-  ObjectPtr CompileTrace(uint8_t* buffer, intptr_t buffer_length);
-
- private:
-  ObjectPtr CompileTriple(const char* uri_cstr,
-                          const char* cls_cstr,
-                          const char* func_cstr);
-  ObjectPtr CompileFunction(const Function& function);
-  void SpeculateInstanceCallTargets(const Function& function);
-
-  Thread* thread_;
-  Zone* zone_;
-  String& uri_;
-  String& class_name_;
-  String& function_name_;
-  String& function_name2_;
-  Library& lib_;
-  Class& cls_;
-  Function& function_;
-  Function& function2_;
-  Field& field_;
-  Array& sites_;
-  ICData& site_;
-  AbstractType& static_type_;
-  Class& receiver_cls_;
-  Function& target_;
-  String& selector_;
-  Array& args_desc_;
-  Object& error_;
-};
-
-class TypeFeedbackSaver : public FunctionVisitor {
- public:
-  explicit TypeFeedbackSaver(BaseWriteStream* stream);
-
-  void WriteHeader();
-  void SaveClasses();
-  void SaveFields();
-  void VisitFunction(const Function& function);
-
- private:
-  void WriteClassByName(const Class& cls);
-  void WriteString(const String& value);
-  void WriteInt(intptr_t value) { stream_->Write(static_cast<int32_t>(value)); }
-
-  BaseWriteStream* const stream_;
-  Class& cls_;
-  Library& lib_;
-  String& str_;
-  Array& fields_;
-  Field& field_;
-  Code& code_;
-  Array& call_sites_;
-  ICData& call_site_;
-};
-
-class TypeFeedbackLoader : public ValueObject {
- public:
-  explicit TypeFeedbackLoader(Thread* thread);
-  ~TypeFeedbackLoader();
-
-  ObjectPtr LoadFeedback(ReadStream* stream);
-
- private:
-  ObjectPtr CheckHeader();
-  ObjectPtr LoadClasses();
-  ObjectPtr LoadFields();
-  ObjectPtr LoadFunction();
-  FunctionPtr FindFunction(UntaggedFunction::Kind kind,
-                           const TokenPosition& token_pos);
-
-  ClassPtr ReadClassByName();
-  StringPtr ReadString();
-  intptr_t ReadInt() { return stream_->Read<int32_t>(); }
-
-  Thread* thread_;
-  Zone* zone_;
-  ReadStream* stream_;
-  intptr_t num_cids_;
-  intptr_t* cid_map_;
-  String& uri_;
-  Library& lib_;
-  String& cls_name_;
-  Class& cls_;
-  String& field_name_;
-  Array& fields_;
-  Field& field_;
-  String& func_name_;
-  Function& func_;
-  Array& call_sites_;
-  ICData& call_site_;
-  String& target_name_;
-  Function& target_;
-  Array& args_desc_;
-  GrowableObjectArray& functions_to_compile_;
-  Object& error_;
-};
-
-}  // namespace dart
-
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
-
-#endif  // RUNTIME_VM_COMPILATION_TRACE_H_
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 8b0cd3d..7ba1fc0 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -13,7 +13,6 @@
 #include "platform/unicode.h"
 #include "vm/class_finalizer.h"
 #include "vm/clustered_snapshot.h"
-#include "vm/compilation_trace.h"
 #include "vm/compiler/jit/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
@@ -6410,94 +6409,6 @@
   thread->SetName(name);
 }
 
-DART_EXPORT
-Dart_Handle Dart_SaveCompilationTrace(uint8_t** buffer,
-                                      intptr_t* buffer_length) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
-#else
-  Thread* thread = Thread::Current();
-  API_TIMELINE_DURATION(thread);
-  DARTSCOPE(thread);
-  CHECK_NULL(buffer);
-  CHECK_NULL(buffer_length);
-  CompilationTraceSaver saver(thread->zone());
-  ProgramVisitor::WalkProgram(thread->zone(), thread->isolate_group(), &saver);
-  saver.StealBuffer(buffer, buffer_length);
-  return Api::Success();
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-}
-
-DART_EXPORT
-Dart_Handle Dart_SaveTypeFeedback(uint8_t** buffer, intptr_t* buffer_length) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
-#else
-  Thread* thread = Thread::Current();
-  API_TIMELINE_DURATION(thread);
-  DARTSCOPE(thread);
-  CHECK_NULL(buffer);
-  CHECK_NULL(buffer_length);
-
-  ZoneWriteStream stream(Api::TopScope(thread)->zone(), MB);
-  TypeFeedbackSaver saver(&stream);
-  saver.WriteHeader();
-  saver.SaveClasses();
-  saver.SaveFields();
-  ProgramVisitor::WalkProgram(thread->zone(), thread->isolate_group(), &saver);
-  *buffer = stream.buffer();
-  *buffer_length = stream.bytes_written();
-
-  return Api::Success();
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-}
-
-DART_EXPORT
-Dart_Handle Dart_LoadCompilationTrace(uint8_t* buffer, intptr_t buffer_length) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
-#else
-  Thread* thread = Thread::Current();
-  API_TIMELINE_DURATION(thread);
-  DARTSCOPE(thread);
-  CHECK_NULL(buffer);
-  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
-  if (Api::IsError(state)) {
-    return state;
-  }
-  CompilationTraceLoader loader(thread);
-  const Object& error =
-      Object::Handle(loader.CompileTrace(buffer, buffer_length));
-  if (error.IsError()) {
-    return Api::NewHandle(T, Error::Cast(error).ptr());
-  }
-  return Api::Success();
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-}
-
-DART_EXPORT
-Dart_Handle Dart_LoadTypeFeedback(uint8_t* buffer, intptr_t buffer_length) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-  return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
-#else
-  Thread* thread = Thread::Current();
-  API_TIMELINE_DURATION(thread);
-  DARTSCOPE(thread);
-  CHECK_NULL(buffer);
-  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
-  if (Api::IsError(state)) {
-    return state;
-  }
-  ReadStream stream(buffer, buffer_length);
-  TypeFeedbackLoader loader(thread);
-  const Object& error = Object::Handle(loader.LoadFeedback(&stream));
-  if (error.IsError()) {
-    return Api::NewHandle(T, Error::Cast(error).ptr());
-  }
-  return Api::Success();
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-}
-
 DART_EXPORT Dart_Handle Dart_SortClasses() {
 #if defined(DART_PRECOMPILED_RUNTIME)
   return Api::NewError("%s: Cannot compile on an AOT runtime.", CURRENT_FUNC);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 07f8188..b78b400 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -20252,7 +20252,6 @@
   if (stub.IsNull()) {
     // This only happens during bootstrapping when creating Type objects before
     // we have the instructions.
-    ASSERT(type_class_id() == kDynamicCid || type_class_id() == kVoidCid);
     StoreNonPointer(&untag()->type_test_stub_entry_point_, 0);
     untag()->set_type_test_stub(stub.ptr());
     return;
diff --git a/runtime/vm/stub_code.cc b/runtime/vm/stub_code.cc
index 78a3355..aee8934 100644
--- a/runtime/vm/stub_code.cc
+++ b/runtime/vm/stub_code.cc
@@ -35,6 +35,7 @@
     VM_STUB_CODE_LIST(STUB_CODE_DECLARE)
 #undef STUB_CODE_DECLARE
 };
+AcqRelAtomic<bool> StubCode::initialized_ = {false};
 
 #if defined(DART_PRECOMPILED_RUNTIME)
 void StubCode::Init() {
@@ -84,6 +85,8 @@
     ASSERT(StubCode::UnknownDartCode().IsFunctionCode());
   }
 #endif  // defined(DART_PRECOMPILER)
+
+  InitializationDone();
 }
 
 #undef STUB_CODE_GENERATE
@@ -111,16 +114,13 @@
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
 
 void StubCode::Cleanup() {
+  initialized_.store(false, std::memory_order_release);
+
   for (size_t i = 0; i < ARRAY_SIZE(entries_); i++) {
     entries_[i].code = nullptr;
   }
 }
 
-bool StubCode::HasBeenInitialized() {
-  // Use AsynchronousGapMarker as canary.
-  return entries_[kAsynchronousGapMarkerIndex].code != nullptr;
-}
-
 bool StubCode::InInvocationStub(uword pc) {
   ASSERT(HasBeenInitialized());
   uword entry = StubCode::InvokeDartCode().EntryPoint();
diff --git a/runtime/vm/stub_code.h b/runtime/vm/stub_code.h
index 6dcedc5..ae39cae 100644
--- a/runtime/vm/stub_code.h
+++ b/runtime/vm/stub_code.h
@@ -42,7 +42,12 @@
   static void Cleanup();
 
   // Returns true if stub code has been initialized.
-  static bool HasBeenInitialized();
+  static bool HasBeenInitialized() {
+    return initialized_.load(std::memory_order_acquire);
+  }
+  static void InitializationDone() {
+    initialized_.store(true, std::memory_order_release);
+  }
 
   // Check if specified pc is in the dart invocation stub used for
   // transitioning into dart code.
@@ -120,6 +125,7 @@
 #endif
   };
   static StubCodeEntry entries_[kNumStubEntries];
+  static AcqRelAtomic<bool> initialized_;
 };
 
 }  // namespace dart
diff --git a/runtime/vm/thread_test.cc b/runtime/vm/thread_test.cc
index 24cb5b9..2eba0fb 100644
--- a/runtime/vm/thread_test.cc
+++ b/runtime/vm/thread_test.cc
@@ -1012,8 +1012,8 @@
 template <typename LockType, typename LockerType>
 static void RunLockerWithLongJumpTest() {
   const intptr_t kNumIterations = 5;
-  intptr_t execution_count = 0;
-  intptr_t thrown_count = 0;
+  volatile intptr_t execution_count = 0;
+  volatile intptr_t thrown_count = 0;
   LockType lock;
   for (intptr_t i = 0; i < kNumIterations; ++i) {
     LongJumpScope jump;
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index 879677c..98842ce 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -106,9 +106,6 @@
   // During bootstrapping we have no access to stubs yet, so we'll just return
   // `null` and patch these later in `Object::FinishInit()`.
   if (!StubCode::HasBeenInitialized()) {
-    ASSERT(type.IsType());
-    const classid_t cid = type.type_class_id();
-    ASSERT(cid == kDynamicCid || cid == kVoidCid);
     return Code::null();
   }
 
diff --git a/runtime/vm/vm_sources.gni b/runtime/vm/vm_sources.gni
index 2d68f1e..8d6dcb2 100644
--- a/runtime/vm/vm_sources.gni
+++ b/runtime/vm/vm_sources.gni
@@ -45,8 +45,6 @@
   "code_patcher_arm64.cc",
   "code_patcher_ia32.cc",
   "code_patcher_x64.cc",
-  "compilation_trace.cc",
-  "compilation_trace.h",
   "constants_arm.cc",
   "constants_arm.h",
   "constants_arm64.cc",
diff --git a/tools/VERSION b/tools/VERSION
index b336d1d..6288f25 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 232
+PRERELEASE 233
 PRERELEASE_PATCH 0
\ No newline at end of file