Version 2.12.0-247.0.dev
Merge commit '54402fb7e0633e6608ecefa73d04014fed61340a' into 'dev'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a6ea3d3..01e66a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,15 +2,21 @@
### Language
-**Breaking Change** [Null
-Safety](https://dart.dev/null-safety/understanding-null-safety) is now enabled
-by default in all packages with a lower sdk constraint of 2.12.0 or greater.
-Files that are not subject to language versioning (whether because they are not
-contained in a pub package, or because the package that they are contained in
-has no lower sdk constraint) are treated as opted into to null safety by default
-and may report new errors. Pub packages may be opted out of null safety by
-setting a min sdk constraint in pubspec.yaml of 2.9.0 or less. Files may be
-opted out of null safety by adding `// @dart=2.9` to the beginning of the file.
+* **Breaking Change** [Null
+ Safety](https://dart.dev/null-safety/understanding-null-safety) is now
+ enabled by default in all packages with a lower sdk constraint of 2.12.0 or
+ greater. Files that are not subject to language versioning (whether because
+ they are not contained in a pub package, or because the package that they
+ are contained in has no lower sdk constraint) are treated as opted into to
+ null safety by default and may report new errors. Pub packages may be opted
+ out of null safety by setting a min sdk constraint in pubspec.yaml of 2.9.0
+ or less. Files may be opted out of null safety by adding `// @dart=2.9` to
+ the beginning of the file.
+
+* **Breaking Change** [#44660][]: Fixed an implementation bug where `this`
+ would sometimes undergo type promotion in extensions.
+
+[#44660]: https://github.com/dart-lang/sdk/issues/44660
### Core libraries
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 2ed8e78..562c83d 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -240,6 +240,7 @@
CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME,
CompileTimeErrorCode.INVALID_EXTENSION_ARGUMENT_COUNT,
CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS,
+ CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE,
CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE,
CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR,
CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER,
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index ceb0cb5..99b2de4 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -5891,6 +5891,23 @@
hasPublishedDocs: true);
/**
+ * Parameters:
+ * 0: the name of the declared member that is not a valid override.
+ * 1: the name of the interface that declares the member.
+ * 2: the type of the declared member in the interface.
+ * 3. the name of the interface with the overridden member.
+ * 4. the type of the overridden member.
+ *
+ * These parameters must be kept in sync with those of
+ * [CompileTimeErrorCode.INVALID_OVERRIDE].
+ */
+ static const CompileTimeErrorCode INVALID_IMPLEMENTATION_OVERRIDE =
+ CompileTimeErrorCode(
+ 'INVALID_IMPLEMENTATION_OVERRIDE',
+ "'{1}.{0}' ('{2}') isn't a valid concrete implementation of "
+ "'{3}.{0}' ('{4}').");
+
+ /**
* No parameters.
*/
// #### Description
diff --git a/pkg/analyzer/lib/src/error/correct_override.dart b/pkg/analyzer/lib/src/error/correct_override.dart
index 79dbec0..f456ab8 100644
--- a/pkg/analyzer/lib/src/error/correct_override.dart
+++ b/pkg/analyzer/lib/src/error/correct_override.dart
@@ -6,6 +6,7 @@
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/error/error.dart';
import 'package:analyzer/error/listener.dart';
import 'package:analyzer/src/dart/analysis/session.dart';
import 'package:analyzer/src/dart/element/element.dart';
@@ -48,11 +49,12 @@
@required ExecutableElement superMember,
@required ErrorReporter errorReporter,
@required AstNode errorNode,
+ ErrorCode errorCode,
}) {
var isCorrect = isCorrectOverrideOf(superMember: superMember);
if (!isCorrect) {
errorReporter.reportErrorForNode(
- CompileTimeErrorCode.INVALID_OVERRIDE,
+ errorCode ?? CompileTimeErrorCode.INVALID_OVERRIDE,
errorNode,
[
_thisMember.name,
diff --git a/pkg/analyzer/lib/src/error/inheritance_override.dart b/pkg/analyzer/lib/src/error/inheritance_override.dart
index b46391b..72a8b0c 100644
--- a/pkg/analyzer/lib/src/error/inheritance_override.dart
+++ b/pkg/analyzer/lib/src/error/inheritance_override.dart
@@ -237,6 +237,7 @@
superMember: interfaceElement,
errorReporter: reporter,
errorNode: classNameNode,
+ errorCode: CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE,
);
}
diff --git a/pkg/analyzer/test/generated/static_warning_code_test.dart b/pkg/analyzer/test/generated/static_warning_code_test.dart
index de9b311..25cd672 100644
--- a/pkg/analyzer/test/generated/static_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_warning_code_test.dart
@@ -82,7 +82,7 @@
foo(x, [y]);
}
class E extends C implements D {}''', [
- error(CompileTimeErrorCode.INVALID_OVERRIDE, 73, 1),
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 73, 1),
]);
}
diff --git a/pkg/analyzer/test/src/diagnostics/invalid_implementation_override_test.dart b/pkg/analyzer/test/src/diagnostics/invalid_implementation_override_test.dart
new file mode 100644
index 0000000..dba5d65
--- /dev/null
+++ b/pkg/analyzer/test/src/diagnostics/invalid_implementation_override_test.dart
@@ -0,0 +1,115 @@
+// 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.
+
+import 'package:analyzer/src/error/codes.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/context_collection_resolution.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(InvalidImplementationOverrideTest);
+ defineReflectiveTests(InvalidImplementationOverrideWithNullSafetyTest);
+ });
+}
+
+@reflectiveTest
+class InvalidImplementationOverrideTest extends PubPackageResolutionTest {
+ test_getter_abstractOverridesConcrete() async {
+ await assertErrorsInCode('''
+class A {
+ num get g => 7;
+}
+class B extends A {
+ int get g;
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 36, 1),
+ ]);
+ }
+
+ test_method_abstractOverridesConcrete() async {
+ await assertErrorsInCode('''
+class A {
+ int add(int a, int b) => a + b;
+}
+class B extends A {
+ int add();
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 52, 1),
+ error(CompileTimeErrorCode.INVALID_OVERRIDE, 72, 3),
+ ]);
+ }
+
+ test_method_abstractOverridesConcrete_expandedParameterType() async {
+ await assertErrorsInCode('''
+class A {
+ int add(int a) => a;
+}
+class B extends A {
+ int add(num a);
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 41, 1),
+ ]);
+ }
+
+ test_method_abstractOverridesConcrete_expandedParameterType_covariant() async {
+ await assertNoErrorsInCode('''
+class A {
+ int add(covariant int a) => a;
+}
+class B extends A {
+ int add(num a);
+}
+''');
+ }
+
+ test_method_abstractOverridesConcrete_withOptional() async {
+ await assertErrorsInCode('''
+class A {
+ int add() => 7;
+}
+class B extends A {
+ int add([int a = 0, int b = 0]);
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 36, 1),
+ ]);
+ }
+
+ test_method_abstractOverridesConcreteInMixin() async {
+ await assertErrorsInCode('''
+mixin M {
+ int add(int a, int b) => a + b;
+}
+class A with M {
+ int add();
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 52, 1),
+ error(CompileTimeErrorCode.INVALID_OVERRIDE, 69, 3),
+ ]);
+ }
+
+ test_method_abstractOverridesConcreteViaMixin() async {
+ await assertErrorsInCode('''
+class A {
+ int add(int a, int b) => a + b;
+}
+mixin M {
+ int add();
+}
+class B extends A with M {}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 77, 1),
+ error(CompileTimeErrorCode.INVALID_OVERRIDE, 94, 1),
+ ]);
+ }
+}
+
+@reflectiveTest
+class InvalidImplementationOverrideWithNullSafetyTest
+ extends PubPackageResolutionTest with WithNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/diagnostics/invalid_override_test.dart b/pkg/analyzer/test/src/diagnostics/invalid_override_test.dart
index 5d52603..42afb2e 100644
--- a/pkg/analyzer/test/src/diagnostics/invalid_override_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/invalid_override_test.dart
@@ -87,11 +87,40 @@
int add();
}
''', [
- error(CompileTimeErrorCode.INVALID_OVERRIDE, 52, 1),
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 52, 1),
error(CompileTimeErrorCode.INVALID_OVERRIDE, 72, 3),
]);
}
+ test_method_abstractOverridesConcreteInMixin() async {
+ await assertErrorsInCode('''
+mixin M {
+ int add(int a, int b) => a + b;
+}
+class A with M {
+ int add();
+}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 52, 1),
+ error(CompileTimeErrorCode.INVALID_OVERRIDE, 69, 3),
+ ]);
+ }
+
+ test_method_abstractOverridesConcreteViaMixin() async {
+ await assertErrorsInCode('''
+class A {
+ int add(int a, int b) => a + b;
+}
+mixin M {
+ int add();
+}
+class B extends A with M {}
+''', [
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 77, 1),
+ error(CompileTimeErrorCode.INVALID_OVERRIDE, 94, 1),
+ ]);
+ }
+
test_method_covariant_1() async {
await assertNoErrorsInCode(r'''
abstract class A<T> {
diff --git a/pkg/analyzer/test/src/diagnostics/test_all.dart b/pkg/analyzer/test/src/diagnostics/test_all.dart
index 0c6341c..58ee594 100644
--- a/pkg/analyzer/test/src/diagnostics/test_all.dart
+++ b/pkg/analyzer/test/src/diagnostics/test_all.dart
@@ -290,6 +290,8 @@
as invalid_factory_name_not_a_class;
import 'invalid_field_type_in_struct_test.dart' as invalid_field_type_in_struct;
import 'invalid_immutable_annotation_test.dart' as invalid_immutable_annotation;
+import 'invalid_implementation_override_test.dart'
+ as invalid_implementation_override;
import 'invalid_internal_annotation_test.dart' as invalid_internal_annotation;
import 'invalid_language_override_greater_test.dart'
as invalid_language_override_greater;
@@ -850,6 +852,7 @@
invalid_factory_name_not_a_class.main();
invalid_field_type_in_struct.main();
invalid_immutable_annotation.main();
+ invalid_implementation_override.main();
invalid_internal_annotation.main();
invalid_language_override_greater.main();
invalid_language_override.main();
diff --git a/pkg/analyzer/test/src/task/strong/checker_test.dart b/pkg/analyzer/test/src/task/strong/checker_test.dart
index 256431b..777a8a1 100644
--- a/pkg/analyzer/test/src/task/strong/checker_test.dart
+++ b/pkg/analyzer/test/src/task/strong/checker_test.dart
@@ -3809,7 +3809,7 @@
class D extends Object with C implements A {}
''', [
- error(CompileTimeErrorCode.INVALID_OVERRIDE, 100, 1),
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 100, 1),
]);
}
@@ -4180,8 +4180,8 @@
class E extends B implements A { }
''', [
error(CompileTimeErrorCode.INVALID_OVERRIDE, 78, 4),
- error(CompileTimeErrorCode.INVALID_OVERRIDE, 159, 1),
- error(CompileTimeErrorCode.INVALID_OVERRIDE, 189, 1),
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 159, 1),
+ error(CompileTimeErrorCode.INVALID_IMPLEMENTATION_OVERRIDE, 189, 1),
]);
}
diff --git a/pkg/dev_compiler/lib/js/legacy/dart_library.js b/pkg/dev_compiler/lib/js/legacy/dart_library.js
index 3c8be22..9be3935 100644
--- a/pkg/dev_compiler/lib/js/legacy/dart_library.js
+++ b/pkg/dev_compiler/lib/js/legacy/dart_library.js
@@ -224,7 +224,7 @@
function reload(clearState) {
// TODO(jmesserly): once we've rolled out `clearState` make it the default,
// and eventually remove the parameter.
- if (clearState == null) clearState = false;
+ if (clearState == null) clearState = true;
// TODO(jmesserly): we may want to change these APIs to use the
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 9a1b17c..349d3f8 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -3101,15 +3101,10 @@
_typeTable.typeContainer.incrementalMode = true;
// Emit function with additional information, such as types that are used
- // in the expression. Note that typeTable can be null if this function is
- // called from the expression compilation service, since we currently do
- // not optimize for size of generated javascript in that scenario.
- // TODO: figure whether or when optimizing for build time vs JavaScript
- // size on expression evaluation is better.
- // Issue: https://github.com/dart-lang/sdk/issues/43288
+ // in the expression.
var fun = _emitFunction(functionNode, name);
- var types = _typeTable?.dischargeBoundTypes();
+ var types = _typeTable.dischargeBoundTypes();
var constants = _dischargeConstTable();
var body = js_ast.Block([...?types, ...?constants, ...fun.body.statements]);
diff --git a/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart b/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
index 74b352d..d7aa824 100644
--- a/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
+++ b/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
@@ -13,7 +13,11 @@
import 'package:front_end/src/api_prototype/file_system.dart';
import 'package:front_end/src/api_unstable/ddc.dart';
import 'package:kernel/ast.dart' show Component, Library;
+import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
+import 'package:kernel/class_hierarchy.dart';
import 'package:kernel/target/targets.dart' show TargetFlags;
+import 'package:kernel/src/tool/find_referenced_libraries.dart'
+ show duplicateLibrariesReachable;
import 'package:meta/meta.dart';
import 'package:vm/http_filesystem.dart';
@@ -24,29 +28,6 @@
import 'expression_compiler.dart';
import 'target.dart';
-/// A wrapper around asset server that redirects file read requests
-/// to http get requests to the asset server.
-class AssetFileSystem extends HttpAwareFileSystem {
- final String server;
- final String port;
-
- AssetFileSystem(FileSystem original, this.server, this.port)
- : super(original);
-
- Uri resourceUri(Uri uri) =>
- Uri.parse('http://$server:$port/getResource?uri=${uri.toString()}');
-
- @override
- FileSystemEntity entityForUri(Uri uri) {
- if (uri.scheme == 'file') {
- return super.entityForUri(uri);
- }
-
- // pass the uri to the asset server in the debugger
- return HttpFileSystemEntity(this, resourceUri(uri));
- }
-}
-
/// The service that handles expression compilation requests from
/// the debugger.
///
@@ -96,10 +77,9 @@
final Stream<Map<String, dynamic>> requestStream;
final void Function(Map<String, dynamic>) sendResponse;
- final _libraryForUri = <Uri, Library>{};
- final _componentForLibrary = <Library, Component>{};
- final _componentForModuleName = <String, Component>{};
- final _componentModuleNames = <Component, String>{};
+ final Map<String, Uri> _fullModules = {};
+ final ModuleCache _moduleCache = ModuleCache();
+
final ProcessedOptions _processedOptions;
final CompilerOptions _compilerOptions;
final Component _sdkComponent;
@@ -206,7 +186,7 @@
return ExpressionCompilerWorker._(processedOptions, compilerOptions,
sdkComponent, requestStream, sendResponse)
- .._update(sdkComponent, dartSdkModule);
+ .._updateCache(sdkComponent, dartSdkModule, true);
}
/// Starts listening and responding to commands.
@@ -220,8 +200,8 @@
if (command == 'Shutdown') break;
switch (command) {
case 'UpdateDeps':
- sendResponse(
- await _updateDeps(UpdateDepsRequest.fromJson(request)));
+ sendResponse(await _updateDependencies(
+ UpdateDependenciesRequest.fromJson(request)));
break;
case 'CompileExpression':
sendResponse(await _compileExpression(
@@ -246,6 +226,8 @@
Future<Map<String, dynamic>> _compileExpression(
CompileExpressionRequest request) async {
var libraryUri = Uri.parse(request.libraryUri);
+ var moduleName = request.moduleName;
+
if (libraryUri.scheme == 'dart') {
// compiling expressions inside the SDK currently fails because
// SDK kernel outlines do not contain information that is needed
@@ -254,25 +236,44 @@
throw Exception('Expression compilation inside SDK is not supported yet');
}
- var originalComponent = _componentForModuleName[request.moduleName];
- if (originalComponent == null) {
- throw ArgumentError(
- 'Unable to find library `$libraryUri`, it must be loaded first.');
- }
- _processedOptions.ticker.logMs(
- 'Compiling expression to JavaScript in module ${request.moduleName}');
- var component = _sdkComponent;
+ _processedOptions.ticker
+ .logMs('Compiling expression to JavaScript in module $moduleName');
+ // Reset linking of libraries to the original state,
+ // so any newly loaded components are linked to the
+ // libraries in the cache.
+ _resetCacheLinks();
+
+ if (!_fullModules.containsKey(moduleName)) {
+ throw StateError('No full dill path available for $moduleName');
+ }
+
+ // Note that this doesn't actually re-load it if it's already fully loaded.
+ if (!await _loadAndUpdateComponent(
+ _fullModules[moduleName], moduleName, false)) {
+ throw ArgumentError('Failed to load full dill for module $moduleName');
+ }
+
+ var originalComponent = _moduleCache.componentForModuleName[moduleName];
+
+ var component = _sdkComponent;
if (libraryUri.scheme != 'dart') {
+ _processedOptions.ticker.logMs('Collecting libraries for $moduleName');
+
var libraries =
_collectTransitiveDependencies(originalComponent, _sdkComponent);
+
+ assert(!duplicateLibrariesReachable(libraries));
+
component = Component(
libraries: libraries,
nameRoot: originalComponent.root,
uriToSource: originalComponent.uriToSource,
- );
+ )..setMainMethodAndMode(
+ originalComponent.mainMethodName, true, originalComponent.mode);
}
- _processedOptions.ticker.logMs('Collected dependencies for expression');
+
+ _processedOptions.ticker.logMs('Collected libraries for $moduleName');
errors.clear();
warnings.clear();
@@ -281,9 +282,11 @@
var incrementalCompiler = IncrementalCompiler.forExpressionCompilationOnly(
CompilerContext(_processedOptions), component, /*resetTicker*/ false);
- var finalComponent =
- await incrementalCompiler.computeDelta(entryPoints: [libraryUri]);
- finalComponent.computeCanonicalNames();
+ var finalComponent = await incrementalCompiler
+ .computeDelta(entryPoints: [libraryUri], fullComponent: true);
+ assert(!duplicateLibrariesReachable(finalComponent.libraries));
+ assert(_canSerialize(finalComponent));
+
_processedOptions.ticker.logMs('Computed delta for expression');
if (errors.isNotEmpty) {
@@ -296,30 +299,52 @@
};
}
- var compiler = ProgramCompiler(
+ var coreTypes = incrementalCompiler.getCoreTypes();
+ var hierarchy = incrementalCompiler.getClassHierarchy();
+
+ var kernel2jsCompiler = ProgramCompiler(
finalComponent,
- incrementalCompiler.getClassHierarchy(),
+ hierarchy,
SharedCompilerOptions(
sourceMap: true,
summarizeApi: false,
- moduleName: request.moduleName,
+ moduleName: moduleName,
// Disable asserts due to failures to load source and
// locations on kernel loaded from dill files in DDC.
// https://github.com/dart-lang/sdk/issues/43986
enableAsserts: false),
- _componentForLibrary,
- _componentModuleNames,
- coreTypes: incrementalCompiler.getCoreTypes(),
+ _moduleCache.componentForLibrary,
+ _moduleCache.moduleNameForComponent,
+ coreTypes: coreTypes,
);
- compiler.emitModule(finalComponent);
+ assert(originalComponent.libraries.toSet().length ==
+ originalComponent.libraries.length);
+
+ // Pick the libraries from finalComponent that's also in originalComponent.
+ // This is needed because originalComponent can contain unreachable things
+ // (i.e. unreachable from the entry point used here).
+ var names = originalComponent.libraries.map((e) => e.importUri).toSet();
+ var librariesToEmit = finalComponent.libraries
+ .where((e) => names.contains(e.importUri))
+ .toList();
+ assert(_librariesAreKnown(hierarchy, librariesToEmit));
+
+ var componentToEmit = Component(
+ libraries: librariesToEmit,
+ nameRoot: finalComponent.root,
+ uriToSource: finalComponent.uriToSource)
+ ..setMainMethodAndMode(
+ originalComponent.mainMethodName, true, originalComponent.mode);
+
+ kernel2jsCompiler.emitModule(componentToEmit);
_processedOptions.ticker.logMs('Emitted module for expression');
var expressionCompiler = ExpressionCompiler(
_compilerOptions,
errors,
incrementalCompiler,
- compiler,
+ kernel2jsCompiler,
finalComponent,
);
@@ -341,44 +366,76 @@
};
}
+ /// Collect libraries reachable from component.
List<Library> _collectTransitiveDependencies(
Component component, Component sdk) {
- var libraries = <Library>{};
- libraries.addAll(sdk.libraries);
+ var visited = <Uri>{};
+ var libraries = <Library>[];
+ var toVisit = <Uri>[];
- var toVisit = <Library>[];
- toVisit.addAll(component.libraries);
+ toVisit.addAll(sdk.libraries.map((e) => e.importUri));
+ toVisit.addAll(component.libraries.map((e) => e.importUri));
while (toVisit.isNotEmpty) {
- var lib = toVisit.removeLast();
- if (!libraries.contains(lib)) {
- libraries.add(lib);
-
- for (var dep in lib.dependencies) {
- var uri = dep.importedLibraryReference.asLibrary.importUri;
- var library = _libraryForUri[uri];
- assert(library == dep.importedLibraryReference.asLibrary);
- toVisit.add(library);
+ var uri = toVisit.removeLast();
+ if (!visited.contains(uri)) {
+ visited.add(uri);
+ if (_moduleCache.libraryForUri.containsKey(uri)) {
+ var lib = _moduleCache.libraryForUri[uri];
+ libraries.add(lib);
+ for (var dep in lib.dependencies) {
+ if (dep.importedLibraryReference.node != null) {
+ toVisit.add(dep.importedLibraryReference.asLibrary.importUri);
+ } else {
+ _processedOptions.ticker.logMs(
+ 'Missing link for ${dep.importedLibraryReference.canonicalName}'
+ ' in ${lib.importUri}');
+ }
+ }
+ } else {
+ _processedOptions.ticker.logMs('No summary found for library: $uri');
}
}
}
- return libraries.toList();
+ return libraries;
}
/// Loads in the specified dill files and invalidates any existing ones.
- Future<Map<String, dynamic>> _updateDeps(UpdateDepsRequest request) async {
+ Future<Map<String, dynamic>> _updateDependencies(
+ UpdateDependenciesRequest request) async {
_processedOptions.ticker
.logMs('Updating dependencies for expression evaluation');
for (var input in request.inputs) {
- var file =
- _processedOptions.fileSystem.entityForUri(Uri.parse(input.path));
- var bytes = await file.readAsBytes();
- var component = await _processedOptions.loadComponent(
- bytes, _sdkComponent.root,
- alwaysCreateNewNamedNodes: true);
- _update(component, input.moduleName);
+ _clearCache(input.moduleName);
+ }
+
+ // Reset linking of libraries to the original state,
+ // so any newly loaded components are linked to the
+ // libraries in the cache.
+ _resetCacheLinks();
+
+ // Load summaries and store paths for full kernel files.
+ // Note that we intentionally ignore loading failures here
+ // as not all of them are fatal. We report missing dependencies
+ // instead on expression evaluation.
+ // TODO(annagrin): throw on load failures when blaze build starts
+ // producing all summaries.
+ for (var input in request.inputs) {
+ // Support older debugger versions that do not provide summary
+ // path by loading full dill kernel instead.
+ var hasSummary = input.summaryPath != null;
+ if (!hasSummary) {
+ _processedOptions.ticker
+ .logMs('Summary path is not provided for ${input.moduleName}.'
+ ' Loading full dill instead.');
+ }
+ var summaryPath = input.summaryPath ?? input.path;
+ await _loadAndUpdateComponent(
+ Uri.parse(summaryPath), input.moduleName, hasSummary);
+
+ _fullModules[input.moduleName] = Uri.parse(input.path);
}
_processedOptions.ticker
@@ -386,34 +443,151 @@
return {'succeeded': true};
}
- void _update(Component component, String moduleName) {
- // do not update dart sdk
+ /// Load component and update cache.
+ Future<bool> _loadAndUpdateComponent(
+ Uri uri, String moduleName, bool isSummary) async {
+ if (isSummary && _moduleCache.isModuleLoaded(moduleName)) return true;
+ if (!isSummary && _moduleCache.isModuleFullyLoaded(moduleName)) return true;
+
+ var component = await _loadComponent(uri);
+ if (component == null) {
+ var componentKind = isSummary ? 'summary' : 'full kernel';
+ _processedOptions.ticker
+ .logMs('Failed to load $componentKind for $moduleName');
+ return false;
+ }
+ _updateCache(component, moduleName, isSummary);
+ return true;
+ }
+
+ Future<Component> _loadComponent(Uri uri) async {
+ var file = _processedOptions.fileSystem.entityForUri(uri);
+ if (await file.exists()) {
+ var bytes = await file.readAsBytes();
+ var component = _processedOptions.loadComponent(bytes, _sdkComponent.root,
+ alwaysCreateNewNamedNodes: true);
+ return component;
+ }
+ return null;
+ }
+
+ void _updateCache(Component component, String moduleName, bool isSummary) {
+ // Do not update dart sdk as we don't expect it to change.
if (moduleName == dartSdkModule &&
- _componentForModuleName.containsKey(moduleName)) {
+ _moduleCache.isModuleLoaded(moduleName)) {
return;
}
+ _moduleCache.addModule(moduleName, component, isSummary);
+ }
- // cleanup old components and libraries
- if (_componentForModuleName.containsKey(moduleName)) {
- var oldComponent = _componentForModuleName[moduleName];
- for (var lib in oldComponent.libraries) {
- _componentForLibrary.remove(lib);
- _libraryForUri.remove(lib.importUri);
- }
- _componentModuleNames.remove(oldComponent);
- _componentForModuleName.remove(moduleName);
+ void _clearCache(String moduleName) {
+ // Do not remove dart sdk as we don't expect it to change.
+ if (moduleName == dartSdkModule) return;
+ _moduleCache.removeModule(moduleName);
+ }
+
+ /// Reset library links and canonical name trees.
+ void _resetCacheLinks() {
+ // Adopting children for the sdk and all already loaded components means
+ // that the root knows about all of it so anything new that is loaded will
+ // link correctly.
+ _sdkComponent.adoptChildren();
+ for (var component in _moduleCache.componentForModuleName.values) {
+ component.adoptChildren();
+ }
+ }
+
+ bool _librariesAreKnown(ClassHierarchy hierarchy, List<Library> libraries) {
+ for (var library in libraries) {
+ if (!hierarchy.knownLibraries.contains(library)) return false;
+ }
+ return true;
+ }
+
+ bool _canSerialize(Component component) {
+ var byteSink = _ByteSink();
+ var printer = BinaryPrinter(byteSink);
+ printer.writeComponentFile(component);
+ return true;
+ }
+}
+
+/// A wrapper around asset server that redirects file read requests
+/// to http get requests to the asset server.
+class AssetFileSystem extends HttpAwareFileSystem {
+ final String server;
+ final String port;
+
+ AssetFileSystem(FileSystem original, this.server, this.port)
+ : super(original);
+
+ Uri resourceUri(Uri uri) =>
+ Uri.parse('http://$server:$port/getResource?uri=${uri.toString()}');
+
+ @override
+ FileSystemEntity entityForUri(Uri uri) {
+ if (uri.scheme == 'file') {
+ return super.entityForUri(uri);
}
- // add new components and libraries
- _componentModuleNames[component] = moduleName;
- _componentForModuleName[moduleName] = component;
+ // Pass the uri to the asset server in the debugger.
+ return HttpFileSystemEntity(this, resourceUri(uri));
+ }
+}
+
+/// Module cache used to load modules and look up loaded libraries.
+///
+/// After each build, the cache is updated with summaries for
+/// new or updated modules. The summaries can be replaced by
+/// full dill kernel during a later expression evaluation in
+/// the corresponding module.
+class ModuleCache {
+ final Map<Uri, Library> libraryForUri = {};
+ final Map<Library, Component> componentForLibrary = {};
+ final Map<String, Component> componentForModuleName = {};
+ final Map<Component, String> moduleNameForComponent = {};
+ final Set<String> fullyLoadedModules = {};
+
+ bool isModuleLoaded(String moduleName) =>
+ componentForModuleName.containsKey(moduleName);
+
+ bool isModuleFullyLoaded(String moduleName) =>
+ fullyLoadedModules.contains(moduleName);
+
+ bool isLibraryLoaded(Library library) =>
+ componentForLibrary.containsKey(library);
+
+ void addModule(String moduleName, Component component, bool isSummary) {
+ moduleNameForComponent[component] = moduleName;
+ componentForModuleName[moduleName] = component;
+ if (!isSummary) fullyLoadedModules.add(moduleName);
+
for (var lib in component.libraries) {
- _componentForLibrary[lib] = component;
- _libraryForUri[lib.importUri] = lib;
+ if (isLibraryLoaded(lib)) {
+ throw Exception('library ${lib.importUri} is already loaded in '
+ '${moduleNameForComponent[componentForLibrary[lib]]}');
+ }
+ componentForLibrary[lib] = component;
+ libraryForUri[lib.importUri] = lib;
+ }
+ }
+
+ void removeModule(String moduleName) {
+ if (isModuleLoaded(moduleName)) {
+ var oldComponent = componentForModuleName[moduleName];
+ for (var lib in oldComponent.libraries) {
+ componentForLibrary.remove(lib);
+ libraryForUri.remove(lib.importUri);
+ }
+
+ moduleNameForComponent.remove(oldComponent);
+ componentForModuleName.remove(moduleName);
+ fullyLoadedModules.remove(moduleName);
}
}
}
+/// Expression compilation request to the expression compilation worker.
class CompileExpressionRequest {
final int column;
final String expression;
@@ -445,23 +619,26 @@
);
}
-class UpdateDepsRequest {
+/// Module update request to the expression compilation worker.
+class UpdateDependenciesRequest {
final List<InputDill> inputs;
- UpdateDepsRequest(this.inputs);
+ UpdateDependenciesRequest(this.inputs);
- factory UpdateDepsRequest.fromJson(Map<String, dynamic> json) =>
- UpdateDepsRequest([
+ factory UpdateDependenciesRequest.fromJson(Map<String, dynamic> json) =>
+ UpdateDependenciesRequest([
for (var input in json['inputs'] as List)
- InputDill(input['path'] as String, input['moduleName'] as String),
+ InputDill(input['path'] as String, input['summaryPath'] as String,
+ input['moduleName'] as String),
]);
}
class InputDill {
final String moduleName;
final String path;
+ final String summaryPath;
- InputDill(this.path, this.moduleName);
+ InputDill(this.path, this.summaryPath, this.moduleName);
}
void Function(DiagnosticMessage) _onDiagnosticHandler(
@@ -501,3 +678,15 @@
Uri _argToUri(String uriArg) =>
uriArg == null ? null : Uri.base.resolve(uriArg.replaceAll('\\', '/'));
+
+class _ByteSink implements Sink<List<int>> {
+ final BytesBuilder builder = BytesBuilder();
+
+ @override
+ void add(List<int> data) {
+ builder.add(data);
+ }
+
+ @override
+ void close() {}
+}
diff --git a/pkg/dev_compiler/lib/src/kernel/js_interop.dart b/pkg/dev_compiler/lib/src/kernel/js_interop.dart
index 13b1f25..65ab098 100644
--- a/pkg/dev_compiler/lib/src/kernel/js_interop.dart
+++ b/pkg/dev_compiler/lib/src/kernel/js_interop.dart
@@ -120,14 +120,18 @@
/// Returns true iff this element is a JS interop member.
///
-/// The element's library must have `@JS(...)` annotation from `package:js`.
-/// If the element is a class, it must also be marked with `@JS`. Other
-/// elements, such as class members and top-level functions/accessors, should
-/// be marked `external`.
+/// JS annotations are required explicitly on classes. Other elements, such as
+/// class members and top-level functions/accessors, should be marked `external`
+/// and should have directly or indirectly a `JS` annotation. It is sufficient
+/// if the annotation is in the procedure itself or an enclosing element like
+/// the class or library.
bool usesJSInterop(NamedNode n) {
- var library = getLibrary(n);
- return library != null &&
- library.annotations.any(isPublicJSAnnotation) &&
- (n is Procedure && n.isExternal ||
- n is Class && n.annotations.any(isPublicJSAnnotation));
+ if (n is Member && n.isExternal) {
+ return n.enclosingLibrary.annotations.any(isPublicJSAnnotation) ||
+ n.annotations.any(isPublicJSAnnotation) ||
+ (n.enclosingClass?.annotations?.any(isPublicJSAnnotation) ?? false);
+ } else if (n is Class) {
+ return n.annotations.any(isPublicJSAnnotation);
+ }
+ return false;
}
diff --git a/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart b/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
index 501fe6d..e964f5f 100644
--- a/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
+++ b/pkg/dev_compiler/test/expression_compiler/expression_compiler_worker_test.dart
@@ -27,6 +27,7 @@
final String moduleName;
final String jsFileName;
final String fullDillFileName;
+ final String summaryDillFileName;
ModuleConfiguration(
{this.root,
@@ -34,17 +35,20 @@
this.moduleName,
this.libraryUri,
this.jsFileName,
- this.fullDillFileName});
+ this.fullDillFileName,
+ this.summaryDillFileName});
Uri get jsPath => root.resolve('$outputDir/$jsFileName');
Uri get fullDillPath => root.resolve('$outputDir/$fullDillFileName');
+ Uri get summaryDillPath => root.resolve('$outputDir/$summaryDillFileName');
}
class TestProjectConfiguration {
final Directory rootDirectory;
final String outputDir = 'out';
+ final bool soundNullSafety;
- TestProjectConfiguration(this.rootDirectory);
+ TestProjectConfiguration(this.rootDirectory, this.soundNullSafety);
ModuleConfiguration get mainModule => ModuleConfiguration(
root: root,
@@ -52,7 +56,8 @@
moduleName: 'packages/_testPackage/main',
libraryUri: 'org-dartlang-app:/lib/main.dart',
jsFileName: 'main.js',
- fullDillFileName: 'main.full.dill');
+ fullDillFileName: 'main.full.dill',
+ summaryDillFileName: 'main.dill');
ModuleConfiguration get testModule => ModuleConfiguration(
root: root,
@@ -60,23 +65,39 @@
moduleName: 'packages/_testPackage/test_library',
libraryUri: 'package:_testPackage/test_library.dart',
jsFileName: 'test_library.js',
- fullDillFileName: 'test_library.full.dill');
+ fullDillFileName: 'test_library.full.dill',
+ summaryDillFileName: 'test_library.dill');
+ // TODO(annagrin): E.g. this module should have a file included that's not
+ // directly reachable from the libraryUri (i.e. where "too much" has been
+ // bundled).
ModuleConfiguration get testModule2 => ModuleConfiguration(
root: root,
outputDir: outputDir,
moduleName: 'packages/_testPackage/test_library2',
libraryUri: 'package:_testPackage/test_library2.dart',
jsFileName: 'test_library2.js',
- fullDillFileName: 'test_library2.full.dill');
+ fullDillFileName: 'test_library2.full.dill',
+ summaryDillFileName: 'test_library2.dill');
+
+ ModuleConfiguration get testModule3 => ModuleConfiguration(
+ root: root,
+ outputDir: outputDir,
+ moduleName: 'packages/_testPackage/test_library3',
+ libraryUri: 'package:_testPackage/test_library3.dart',
+ jsFileName: 'test_library3.js',
+ fullDillFileName: 'test_library3.full.dill',
+ summaryDillFileName: 'test_library3.dill');
String get rootPath => rootDirectory.path;
Uri get root => rootDirectory.uri;
Uri get outputPath => root.resolve(outputDir);
- Uri get packagesPath => root.resolve('.packages');
+ Uri get packagesPath => root.resolve('package_config.json');
Uri get sdkRoot => computePlatformBinariesLocation();
- Uri get sdkSummaryPath => sdkRoot.resolve('ddc_sdk.dill');
+ Uri get sdkSummaryPath => soundNullSafety
+ ? sdkRoot.resolve('ddc_outline_sound.dill')
+ : sdkRoot.resolve('ddc_sdk.dill');
Uri get librariesPath => sdkRoot.resolve('lib/libraries.json');
void createTestProject() {
@@ -91,25 +112,34 @@
sdk: '>=2.8.0 <3.0.0'
''');
- var packages = root.resolve('.packages');
- File.fromUri(packages)
+ File.fromUri(packagesPath)
..createSync()
..writeAsStringSync('''
-_testPackage:lib/
-''');
+ {
+ "configVersion": 2,
+ "packages": [
+ {
+ "name": "_testPackage",
+ "rootUri": "./lib",
+ "packageUri": "./"
+ }
+ ]
+ }
+ ''');
var main = root.resolve('lib/main.dart');
File.fromUri(main)
..createSync(recursive: true)
..writeAsStringSync('''
-// @dart = 2.9
+
import 'package:_testPackage/test_library.dart';
+import 'package:_testPackage/test_library3.dart';
var global = 0;
void main() {
var count = 0;
- // line 8
+ // line 9
print('Global is: \${++global}');
print('Count is: \${++count}');
@@ -119,17 +149,22 @@
extension NumberParsing on String {
int parseInt() {
var ret = int.parse(this);
- // line 18
+ // line 19
return ret;
}
}
+
+void linkToImports() {
+ testLibraryFunction(42);
+ testLibraryFunction3(42);
+}
''');
var testLibrary = root.resolve('lib/test_library.dart');
File.fromUri(testLibrary)
..createSync()
..writeAsStringSync('''
-// @dart = 2.9
+
import 'package:_testPackage/test_library2.dart';
int testLibraryFunction(int formal) {
@@ -137,11 +172,14 @@
}
int callLibraryFunction2(int formal) {
- return testLibraryFunction2(formal); // line 8
+ return testLibraryFunction2(formal); // line 9
}
class B {
C c() => new C();
+ void printNumber() {
+ print(c().getNumber() + 1);
+ }
}
''');
@@ -149,7 +187,7 @@
File.fromUri(testLibrary2)
..createSync()
..writeAsStringSync('''
-// @dart = 2.9
+
int testLibraryFunction2(int formal) {
return formal; // line 3
}
@@ -158,246 +196,504 @@
int getNumber() => 42;
}
''');
+
+ var testLibrary3 = root.resolve('lib/test_library3.dart');
+ File.fromUri(testLibrary3)
+ ..createSync()
+ ..writeAsStringSync('''
+
+int testLibraryFunction3(int formal) {
+ return formal; // line 3
+}
+''');
}
}
void main() async {
- group('Expression compiler worker (webdev simulation) - ', () {
- ExpressionCompilerWorker worker;
- Future workerDone;
- StreamController<Map<String, dynamic>> requestController;
- StreamController<Map<String, dynamic>> responseController;
- Directory tempDir;
- TestProjectConfiguration config;
- List inputs;
+ for (var soundNullSafety in [true, false]) {
+ group('${soundNullSafety ? "sound" : "unsound"} null safety -', () {
+ for (var summarySupport in [true, false]) {
+ group('${summarySupport ? "" : "no "}debugger summary support -', () {
+ group('expression compiler worker', () {
+ ExpressionCompilerWorker worker;
+ Future workerDone;
+ StreamController<Map<String, dynamic>> requestController;
+ StreamController<Map<String, dynamic>> responseController;
+ Directory tempDir;
+ TestProjectConfiguration config;
+ List inputs;
- setUpAll(() async {
- tempDir = Directory.systemTemp.createTempSync('foo bar');
- config = TestProjectConfiguration(tempDir);
+ setUpAll(() async {
+ tempDir = Directory.systemTemp.createTempSync('foo bar');
+ config = TestProjectConfiguration(tempDir, soundNullSafety);
- // simulate webdev
- config.createTestProject();
- var kernelGenerator = DDCKernelGenerator(config);
- await kernelGenerator.generate();
+ // simulate webdev
+ config.createTestProject();
+ var kernelGenerator = DDCKernelGenerator(config);
+ await kernelGenerator.generate();
- inputs = [
- {
- 'path': config.mainModule.fullDillPath.path,
- 'moduleName': config.mainModule.moduleName
- },
- {
- 'path': config.testModule.fullDillPath.path,
- 'moduleName': config.testModule.moduleName
- },
- {
- 'path': config.testModule2.fullDillPath.path,
- 'moduleName': config.testModule2.moduleName
- },
- ];
+ inputs = [
+ {
+ 'path': config.mainModule.fullDillPath.path,
+ if (summarySupport)
+ 'summaryPath': config.mainModule.summaryDillPath.path,
+ 'moduleName': config.mainModule.moduleName
+ },
+ {
+ 'path': config.testModule.fullDillPath.path,
+ if (summarySupport)
+ 'summaryPath': config.testModule.summaryDillPath.path,
+ 'moduleName': config.testModule.moduleName
+ },
+ {
+ 'path': config.testModule2.fullDillPath.path,
+ if (summarySupport)
+ 'summaryPath': config.testModule2.summaryDillPath.path,
+ 'moduleName': config.testModule2.moduleName
+ },
+ {
+ 'path': config.testModule3.fullDillPath.path,
+ if (summarySupport)
+ 'summaryPath': config.testModule3.summaryDillPath.path,
+ 'moduleName': config.testModule3.moduleName
+ },
+ ];
+ });
+
+ tearDownAll(() async {
+ tempDir.deleteSync(recursive: true);
+ });
+
+ setUp(() async {
+ var fileSystem = MultiRootFileSystem('org-dartlang-app',
+ [tempDir.uri], StandardFileSystem.instance);
+
+ requestController = StreamController<Map<String, dynamic>>();
+ responseController = StreamController<Map<String, dynamic>>();
+ worker = await ExpressionCompilerWorker.create(
+ librariesSpecificationUri: config.librariesPath,
+ // We should be able to load everything from dill and not require
+ // source parsing. Webdev and google3 integration currently rely on
+ // that. Make the test fail on source reading by not providing a
+ // packages file.
+ packagesFile: null,
+ sdkSummary: config.sdkSummaryPath,
+ fileSystem: fileSystem,
+ requestStream: requestController.stream,
+ sendResponse: responseController.add,
+ soundNullSafety: soundNullSafety,
+ verbose: verbose,
+ );
+ workerDone = worker.start();
+ });
+
+ tearDown(() async {
+ unawaited(requestController.close());
+ await workerDone;
+ unawaited(responseController.close());
+ });
+
+ test('can load dependencies and compile expressions in sdk',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'other',
+ 'line': 107,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'other': 'other'},
+ 'libraryUri': 'dart:collection',
+ 'moduleName': 'dart_sdk',
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return other;'),
+ })
+ ]));
+ }, skip: 'Evaluating expressions in SDK is not supported yet');
+
+ test('can load dependencies and compile expressions in a library',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 5,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule.libraryUri,
+ 'moduleName': config.testModule.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ })
+ ]));
+ });
+
+ test('can load dependencies and compile expressions in main',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'count',
+ 'line': 9,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'count': 'count'},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return count;'),
+ })
+ ]));
+ });
+
+ test(
+ 'can load dependencies and compile expressions in main (extension method)',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'ret',
+ 'line': 19,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'ret': 'ret'},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return ret;'),
+ })
+ ]));
+ });
+
+ test(
+ 'can load dependencies and compile transitive expressions in main',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().c().getNumber()',
+ 'line': 9,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains(
+ 'return new test_library.B.new().c().getNumber()'),
+ })
+ ]));
+ });
+
+ test('can compile series of expressions in various libraries',
+ () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().c().getNumber()',
+ 'line': 8,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 5,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule.libraryUri,
+ 'moduleName': config.testModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 3,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule2.libraryUri,
+ 'moduleName': config.testModule2.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 3,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule3.libraryUri,
+ 'moduleName': config.testModule3.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().printNumber()',
+ 'line': 9,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure':
+ contains('new test_library.B.new().c().getNumber()'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure':
+ contains('test_library.B.new().printNumber()'),
+ })
+ ]));
+ });
+
+ test('can compile after dependency update', () async {
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().c().getNumber()',
+ 'line': 8,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 5,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule.libraryUri,
+ 'moduleName': config.testModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().printNumber()',
+ 'line': 9,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'UpdateDeps',
+ 'inputs': inputs,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'B().c().getNumber()',
+ 'line': 8,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {},
+ 'libraryUri': config.mainModule.libraryUri,
+ 'moduleName': config.mainModule.moduleName,
+ });
+
+ requestController.add({
+ 'command': 'CompileExpression',
+ 'expression': 'formal',
+ 'line': 3,
+ 'column': 1,
+ 'jsModules': {},
+ 'jsScope': {'formal': 'formal'},
+ 'libraryUri': config.testModule3.libraryUri,
+ 'moduleName': config.testModule3.moduleName,
+ });
+
+ expect(
+ responseController.stream,
+ emitsInOrder([
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure':
+ contains('new test_library.B.new().c().getNumber()'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure':
+ contains('test_library.B.new().printNumber()'),
+ }),
+ equals({
+ 'succeeded': true,
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure':
+ contains('new test_library.B.new().c().getNumber()'),
+ }),
+ equals({
+ 'succeeded': true,
+ 'errors': isEmpty,
+ 'warnings': isEmpty,
+ 'infos': isEmpty,
+ 'compiledProcedure': contains('return formal;'),
+ }),
+ ]));
+ });
+ });
+ });
+ }
});
-
- tearDownAll(() async {
- tempDir.deleteSync(recursive: true);
- });
-
- setUp(() async {
- var fileSystem = MultiRootFileSystem(
- 'org-dartlang-app', [tempDir.uri], StandardFileSystem.instance);
-
- requestController = StreamController<Map<String, dynamic>>();
- responseController = StreamController<Map<String, dynamic>>();
- worker = await ExpressionCompilerWorker.create(
- librariesSpecificationUri: config.librariesPath,
- // We should be able to load everything from dill and not require
- // source parsing. Webdev and google3 integration currently rely on
- // that. Make the test fail on source reading by not providing a
- // packages file.
- packagesFile: null,
- sdkSummary: config.sdkSummaryPath,
- fileSystem: fileSystem,
- requestStream: requestController.stream,
- sendResponse: responseController.add,
- verbose: verbose,
- );
- workerDone = worker.start();
- });
-
- tearDown(() async {
- unawaited(requestController.close());
- await workerDone;
- unawaited(responseController.close());
- });
-
- test('can load dependencies and compile expressions in sdk', () async {
- requestController.add({
- 'command': 'UpdateDeps',
- 'inputs': inputs,
- });
-
- requestController.add({
- 'command': 'CompileExpression',
- 'expression': 'other',
- 'line': 107,
- 'column': 1,
- 'jsModules': {},
- 'jsScope': {'other': 'other'},
- 'libraryUri': 'dart:collection',
- 'moduleName': 'dart_sdk',
- });
-
- expect(
- responseController.stream,
- emitsInOrder([
- equals({
- 'succeeded': true,
- }),
- equals({
- 'succeeded': true,
- 'errors': isEmpty,
- 'warnings': isEmpty,
- 'infos': isEmpty,
- 'compiledProcedure': contains('return other;'),
- })
- ]));
- }, skip: 'Evaluating expressions in SDK is not supported yet');
-
- test('can load dependencies and compile expressions in a library',
- () async {
- requestController.add({
- 'command': 'UpdateDeps',
- 'inputs': inputs,
- });
-
- requestController.add({
- 'command': 'CompileExpression',
- 'expression': 'formal',
- 'line': 5,
- 'column': 1,
- 'jsModules': {},
- 'jsScope': {'formal': 'formal'},
- 'libraryUri': config.testModule.libraryUri,
- 'moduleName': config.testModule.moduleName,
- });
-
- expect(
- responseController.stream,
- emitsInOrder([
- equals({
- 'succeeded': true,
- }),
- equals({
- 'succeeded': true,
- 'errors': isEmpty,
- 'warnings': isEmpty,
- 'infos': isEmpty,
- 'compiledProcedure': contains('return formal;'),
- })
- ]));
- });
-
- test('can load dependencies and compile expressions in main', () async {
- requestController.add({
- 'command': 'UpdateDeps',
- 'inputs': inputs,
- });
-
- requestController.add({
- 'command': 'CompileExpression',
- 'expression': 'count',
- 'line': 8,
- 'column': 1,
- 'jsModules': {},
- 'jsScope': {'count': 'count'},
- 'libraryUri': config.mainModule.libraryUri,
- 'moduleName': config.mainModule.moduleName,
- });
-
- expect(
- responseController.stream,
- emitsInOrder([
- equals({
- 'succeeded': true,
- }),
- equals({
- 'succeeded': true,
- 'errors': isEmpty,
- 'warnings': isEmpty,
- 'infos': isEmpty,
- 'compiledProcedure': contains('return count;'),
- })
- ]));
- });
-
- test(
- 'can load dependencies and compile expressions in main (extension method)',
- () async {
- requestController.add({
- 'command': 'UpdateDeps',
- 'inputs': inputs,
- });
-
- requestController.add({
- 'command': 'CompileExpression',
- 'expression': 'ret',
- 'line': 18,
- 'column': 1,
- 'jsModules': {},
- 'jsScope': {'ret': 'ret'},
- 'libraryUri': config.mainModule.libraryUri,
- 'moduleName': config.mainModule.moduleName,
- });
-
- expect(
- responseController.stream,
- emitsInOrder([
- equals({
- 'succeeded': true,
- }),
- equals({
- 'succeeded': true,
- 'errors': isEmpty,
- 'warnings': isEmpty,
- 'infos': isEmpty,
- 'compiledProcedure': contains('return ret;'),
- })
- ]));
- });
-
- test('can load dependencies and compile transitive expressions in main',
- () async {
- requestController.add({
- 'command': 'UpdateDeps',
- 'inputs': inputs,
- });
-
- requestController.add({
- 'command': 'CompileExpression',
- 'expression': 'B().c().getNumber()',
- 'line': 8,
- 'column': 1,
- 'jsModules': {},
- 'jsScope': {},
- 'libraryUri': config.mainModule.libraryUri,
- 'moduleName': config.mainModule.moduleName,
- });
-
- expect(
- responseController.stream,
- emitsInOrder([
- equals({
- 'succeeded': true,
- }),
- equals({
- 'succeeded': true,
- 'errors': isEmpty,
- 'warnings': isEmpty,
- 'infos': isEmpty,
- 'compiledProcedure':
- contains('return new test_library.B.new().c().getNumber()'),
- })
- ]));
- });
- });
+ }
}
/// Uses DDC to generate kernel from the test code
@@ -414,11 +710,35 @@
Directory.fromUri(config.outputPath)..createSync();
- // generate test_library2.full.dill
+ // generate test_library3.full.dill
var args = [
dartdevc,
+ config.testModule3.libraryUri,
+ '-o',
+ config.testModule3.jsPath.toFilePath(),
+ '--source-map',
+ '--experimental-emit-debug-metadata',
+ '--experimental-output-compiled-kernel',
+ '--dart-sdk-summary',
+ config.sdkSummaryPath.path,
+ '--multi-root',
+ '${config.root}',
+ '--multi-root-scheme',
+ 'org-dartlang-app',
+ '--packages',
+ config.packagesPath.path,
+ config.soundNullSafety ? '--sound-null-safety' : '--no-sound-null-safety'
+ ];
+
+ var exitCode = await runProcess(dart, args, config.rootPath);
+ if (exitCode != 0) {
+ return exitCode;
+ }
+
+ // generate test_library2.full.dill
+ args = [
+ dartdevc,
config.testModule2.libraryUri,
- '--no-summarize',
'-o',
config.testModule2.jsPath.toFilePath(),
'--source-map',
@@ -432,9 +752,10 @@
'org-dartlang-app',
'--packages',
config.packagesPath.path,
+ if (config.soundNullSafety) '--sound-null-safety',
];
- var exitCode = await runProcess(dart, args, config.rootPath);
+ exitCode = await runProcess(dart, args, config.rootPath);
if (exitCode != 0) {
return exitCode;
}
@@ -443,9 +764,8 @@
args = [
dartdevc,
config.testModule.libraryUri,
- '--no-summarize',
'--summary',
- '${config.testModule2.fullDillPath}=${config.testModule2.moduleName}',
+ '${config.testModule2.summaryDillPath}=${config.testModule2.moduleName}',
'-o',
config.testModule.jsPath.toFilePath(),
'--source-map',
@@ -459,6 +779,7 @@
'org-dartlang-app',
'--packages',
config.packagesPath.path,
+ if (config.soundNullSafety) '--sound-null-safety',
];
exitCode = await runProcess(dart, args, config.rootPath);
@@ -470,11 +791,10 @@
args = [
dartdevc,
config.mainModule.libraryUri,
- '--no-summarize',
'--summary',
- '${config.testModule2.fullDillPath}=${config.testModule2.moduleName}',
+ '${config.testModule3.summaryDillPath}=${config.testModule3.moduleName}',
'--summary',
- '${config.testModule.fullDillPath}=${config.testModule.moduleName}',
+ '${config.testModule.summaryDillPath}=${config.testModule.moduleName}',
'-o',
config.mainModule.jsPath.toFilePath(),
'--source-map',
@@ -487,7 +807,8 @@
'--multi-root-scheme',
'org-dartlang-app',
'--packages',
- config.packagesPath.path,
+ config.packagesPath.toFilePath(),
+ if (config.soundNullSafety) '--sound-null-safety',
];
return await runProcess(dart, args, config.rootPath);
diff --git a/pkg/nnbd_migration/lib/instrumentation.dart b/pkg/nnbd_migration/lib/instrumentation.dart
index 434a003..5295242 100644
--- a/pkg/nnbd_migration/lib/instrumentation.dart
+++ b/pkg/nnbd_migration/lib/instrumentation.dart
@@ -7,6 +7,7 @@
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:nnbd_migration/src/edit_plan.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
/// Data structure used by the nullability migration engine to refer to a
/// specific location in source code.
@@ -303,32 +304,6 @@
/// about a reason for a modification to the source file.
abstract class FixReasonInfo {}
-/// Enum describing the possible hints that can be performed on an edge or a
-/// node.
-///
-/// Which actions are available can be built by other visitors, and the hint can
-/// be applied by visitors such as EditPlanner when the user requests it from
-/// the front end.
-enum HintActionKind {
- /// Add a `/*?*/` hint to a type.
- addNullableHint,
-
- /// Add a `/*!*/` hint to a type.
- addNonNullableHint,
-
- /// Change a `/*!*/` hint to a `/*?*/` hint.
- changeToNullableHint,
-
- /// Change a `/*?*/` hint to a `/*!*/` hint.
- changeToNonNullableHint,
-
- /// Remove a `/*?*/` hint.
- removeNullableHint,
-
- /// Remove a `/*!*/` hint.
- removeNonNullableHint,
-}
-
/// Abstract interface for assigning ids numbers to nodes, and performing
/// lookups afterwards.
abstract class NodeMapper extends NodeToIdMapper {
@@ -538,27 +513,3 @@
UpstreamPropagationStepInfo get principalCause;
}
-
-/// Extension methods to make [HintActionKind] act as a smart enum.
-extension HintActionKindBehaviors on HintActionKind {
- /// Get the text description of a [HintActionKind], for display to users.
- String get description {
- switch (this) {
- case HintActionKind.addNullableHint:
- return 'Add /*?*/ hint';
- case HintActionKind.addNonNullableHint:
- return 'Add /*!*/ hint';
- case HintActionKind.removeNullableHint:
- return 'Remove /*?*/ hint';
- case HintActionKind.removeNonNullableHint:
- return 'Remove /*!*/ hint';
- case HintActionKind.changeToNullableHint:
- return 'Change to /*?*/ hint';
- case HintActionKind.changeToNonNullableHint:
- return 'Change to /*!*/ hint';
- }
-
- assert(false);
- return null;
- }
-}
diff --git a/pkg/nnbd_migration/lib/migration_cli.dart b/pkg/nnbd_migration/lib/migration_cli.dart
index df8da53..a727c1c 100644
--- a/pkg/nnbd_migration/lib/migration_cli.dart
+++ b/pkg/nnbd_migration/lib/migration_cli.dart
@@ -591,7 +591,10 @@
Set<String> computePathsToProcess(DriverBasedAnalysisContext context) =>
context.contextRoot
.analyzedFiles()
- .where((s) => s.endsWith('.dart'))
+ .where((s) =>
+ s.endsWith('.dart') &&
+ // Any file may have been deleted since its initial analysis.
+ resourceProvider.getFile(s).exists)
.toSet();
NonNullableFix createNonNullableFix(
@@ -1159,6 +1162,8 @@
_progressBar.complete();
_migrationCli.logger.stdout(_migrationCli.ansi
.emphasized('Compiling instrumentation information...'));
+ // Update the tasks paths-to-process, in case of new or deleted files.
+ _task.pathsToProcess = pathsToProcess;
var state = await _task.finish();
_task.processPackage(context.contextRoot.root, state.neededPackages);
if (_migrationCli.options.webPreview) {
diff --git a/pkg/nnbd_migration/lib/src/front_end/info_builder.dart b/pkg/nnbd_migration/lib/src/front_end/info_builder.dart
index 85f05ac..7852c1d 100644
--- a/pkg/nnbd_migration/lib/src/front_end/info_builder.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/info_builder.dart
@@ -25,6 +25,7 @@
import 'package:nnbd_migration/src/front_end/migration_info.dart';
import 'package:nnbd_migration/src/front_end/offset_mapper.dart';
import 'package:nnbd_migration/src/front_end/web/navigation_tree.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/utilities/progress_bar.dart';
/// A builder used to build the migration information for a library.
@@ -58,6 +59,9 @@
/// migrated.
final bool Function(String) shouldBeMigratedFunction;
+ /// The set of files which are being considered for migration.
+ final Iterable<String> _pathsToProcess;
+
/// Initialize a newly created builder.
InfoBuilder(
this.provider,
@@ -67,7 +71,8 @@
this.migration,
this.nodeMapper,
this._logger,
- this.shouldBeMigratedFunction);
+ this.shouldBeMigratedFunction,
+ this._pathsToProcess);
/// The provider used to get information about libraries.
DriverProviderImpl get driverProvider => listener.server;
@@ -78,11 +83,18 @@
var sourceInfoMap = info.sourceInformation;
Set<UnitInfo> units =
SplayTreeSet<UnitInfo>((u1, u2) => u1.path.compareTo(u2.path));
- var progressBar = ProgressBar(_logger, sourceInfoMap.length);
- for (var source in sourceInfoMap.keys) {
+ // Collect all of the sources for which we have [SourceInformation], as well
+ // as all files which are being "processed" during this migration, which may
+ // include already migrated files.
+ var sources = {
+ ...sourceInfoMap.keys.map((source) => source.fullName),
+ ..._pathsToProcess,
+ };
+ var progressBar = ProgressBar(_logger, sources.length);
+
+ for (var filePath in sources) {
progressBar.tick();
- var filePath = source.fullName;
var session = driverProvider.getAnalysisSession(filePath);
if (!session.getFile(filePath).isPart) {
var result = await session.getResolvedLibrary(filePath);
@@ -101,7 +113,7 @@
sourceInfo ??= SourceInformation();
var edit = listener.sourceChange.getFileEdit(unitResult.path);
var unit = _explainUnit(sourceInfo, unitResult, edit);
- if (provider.pathContext.isWithin(includedPath, unitResult.path)) {
+ if (_pathsToProcess.contains(unitResult.path)) {
units.add(unit);
}
}
diff --git a/pkg/nnbd_migration/lib/src/front_end/migration_info.dart b/pkg/nnbd_migration/lib/src/front_end/migration_info.dart
index f31bcdd..9f261cd 100644
--- a/pkg/nnbd_migration/lib/src/front_end/migration_info.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/migration_info.dart
@@ -6,11 +6,11 @@
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:collection/collection.dart';
import 'package:crypto/crypto.dart';
-import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/nnbd_migration.dart';
import 'package:nnbd_migration/src/front_end/offset_mapper.dart';
import 'package:nnbd_migration/src/front_end/unit_link.dart';
import 'package:nnbd_migration/src/front_end/web/navigation_tree.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/preview/preview_site.dart';
import 'package:path/path.dart' as path;
@@ -39,24 +39,6 @@
sourceEdit.replacement);
}
-/// Everything the front end needs to know to tell the server to perform a hint
-/// action.
-class HintAction {
- final HintActionKind kind;
- final int nodeId;
- HintAction(this.kind, this.nodeId);
-
- HintAction.fromJson(Map<String, Object> json)
- : nodeId = json['nodeId'] as int,
- kind = HintActionKind.values
- .singleWhere((action) => action.index == json['kind']);
-
- Map<String, Object> toJson() => {
- 'nodeId': nodeId,
- 'kind': kind.index,
- };
-}
-
/// A class storing rendering information for an entire migration report.
///
/// This generally provides one [InstrumentationRenderer] (for one library)
diff --git a/pkg/nnbd_migration/lib/src/front_end/migration_state.dart b/pkg/nnbd_migration/lib/src/front_end/migration_state.dart
index 23a0860..d65d0cf 100644
--- a/pkg/nnbd_migration/lib/src/front_end/migration_state.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/migration_state.dart
@@ -77,7 +77,7 @@
}
/// Refresh the state of the migration after the migration has been updated.
- Future<void> refresh(Logger logger) async {
+ Future<void> refresh(Logger logger, Iterable<String> pathsToProcess) async {
assert(!hasBeenApplied);
var provider = listener.server.resourceProvider;
var infoBuilder = InfoBuilder(
@@ -88,7 +88,8 @@
migration,
nodeMapper,
logger,
- shouldBeMigratedFunction);
+ shouldBeMigratedFunction,
+ pathsToProcess);
var unitInfos = await infoBuilder.explainMigration();
var pathContext = provider.pathContext;
migrationInfo = MigrationInfo(
diff --git a/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart b/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
index 4779532..20e8f55 100644
--- a/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/non_nullable_fix.dart
@@ -79,6 +79,9 @@
/// migrated.
final bool Function(String) shouldBeMigratedFunction;
+ /// The set of files which are being considered for migration.
+ Iterable<String> pathsToProcess;
+
/// Completes when the server has been shutdown.
Completer<void> serverIsShutdown;
@@ -116,7 +119,7 @@
var neededPackages = migration.finish();
final state = MigrationState(migration, includedRoot, listener,
instrumentationListener, neededPackages, shouldBeMigratedFunction);
- await state.refresh(_logger);
+ await state.refresh(_logger, pathsToProcess);
return state;
}
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 e620c8e..11f7da9 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
@@ -7708,7 +7708,7 @@
''';
String _migration_js;
-// migration_dart md5 is '46cf7671204b04b89e72a70aae96a7fc'
+// migration_dart md5 is 'ed25ca8e4192ae0a3fd5a19afb8efe5f'
String _migration_js_base64 = '''
KGZ1bmN0aW9uIGRhcnRQcm9ncmFtKCl7ZnVuY3Rpb24gY29weVByb3BlcnRpZXMoYSxiKXt2YXIgcz1P
YmplY3Qua2V5cyhhKQpmb3IodmFyIHI9MDtyPHMubGVuZ3RoO3IrKyl7dmFyIHE9c1tyXQpiW3FdPWFb
@@ -9135,2689 +9135,2689 @@
Vygpe30sCm1rOmZ1bmN0aW9uIG1rKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApLbzpmdW5jdGlvbiBL
byhhKXt0aGlzLmE9YQp0aGlzLmI9ITF9LApmbTpmdW5jdGlvbiBmbShhKXt0aGlzLmE9YX0sCkxlOmZ1
bmN0aW9uIExlKCl7fSwKSzc6ZnVuY3Rpb24gSzcoKXt9LApyQjpmdW5jdGlvbiByQigpe30sClhXOmZ1
-bmN0aW9uIFhXKCl7fSwKb2E6ZnVuY3Rpb24gb2EoKXt9fSxNPXsKT1g6ZnVuY3Rpb24oYSl7c3dpdGNo
-KGEpe2Nhc2UgQy5BZDpyZXR1cm4iQWRkIC8qPyovIGhpbnQiCmNhc2UgQy5uZTpyZXR1cm4iQWRkIC8q
-ISovIGhpbnQiCmNhc2UgQy53VjpyZXR1cm4iUmVtb3ZlIC8qPyovIGhpbnQiCmNhc2UgQy5mUjpyZXR1
-cm4iUmVtb3ZlIC8qISovIGhpbnQiCmNhc2UgQy5teTpyZXR1cm4iQ2hhbmdlIHRvIC8qPyovIGhpbnQi
-CmNhc2UgQy5yeDpyZXR1cm4iQ2hhbmdlIHRvIC8qISovIGhpbnQifXJldHVybiBudWxsfSwKSDc6ZnVu
-Y3Rpb24gSDcoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCllGOmZ1bmN0aW9uKGEsYil7dmFyIHMscixx
-LHAsbyxuLG0sbApmb3Iocz1iLmxlbmd0aCxyPTE7cjxzOysrcil7aWYoYltyXT09bnVsbHx8YltyLTFd
-IT1udWxsKWNvbnRpbnVlCmZvcig7cz49MTtzPXEpe3E9cy0xCmlmKGJbcV0hPW51bGwpYnJlYWt9cD1u
-ZXcgUC5SbigiIikKbz1hKyIoIgpwLmE9bwpuPUgudDYoYikKbT1uLkMoIm5IPDE+IikKbD1uZXcgSC5u
-SChiLDAscyxtKQpsLkhkKGIsMCxzLG4uYykKbT1vK25ldyBILmxKKGwsbS5DKCJxVShhTC5FKSIpLmEo
-bmV3IE0uTm8oKSksbS5DKCJsSjxhTC5FLHFVPiIpKS5rKDAsIiwgIikKcC5hPW0KcC5hPW0rKCIpOiBw
-YXJ0ICIrKHItMSkrIiB3YXMgbnVsbCwgYnV0IHBhcnQgIityKyIgd2FzIG5vdC4iKQp0aHJvdyBILmIo
-UC54WShwLncoMCkpKX19LApsSTpmdW5jdGlvbiBsSShhKXt0aGlzLmE9YX0sCnE3OmZ1bmN0aW9uIHE3
-KCl7fSwKTm86ZnVuY3Rpb24gTm8oKXt9fSxVPXsKbno6ZnVuY3Rpb24oYSl7dmFyIHM9SC51UChhLnEo
-MCwibm9kZUlkIikpCnJldHVybiBuZXcgVS5MTChDLk5tLkh0KEMucmssbmV3IFUuTUQoYSkpLHMpfSwK
-TEw6ZnVuY3Rpb24gTEwoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCk1EOmZ1bmN0aW9uIE1EKGEpe3Ro
-aXMuYT1hfSwKamY6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAKaWYoYT09bnVsbClzPW51bGwKZWxzZXtz
-PUguVk0oW10sdC5kNykKZm9yKHI9Si5JVCh0LlUuYShhKSk7ci5GKCk7KXtxPXIuZ2woKQpwPUouVTYo
-cSkKcy5wdXNoKG5ldyBVLlNlKEguaChwLnEocSwiZGVzY3JpcHRpb24iKSksSC5oKHAucShxLCJocmVm
-IikpKSl9fXJldHVybiBzfSwKTmQ6ZnVuY3Rpb24oYSl7dmFyIHMscgppZihhPT1udWxsKXM9bnVsbApl
-bHNle3M9SC5WTShbXSx0LmFBKQpmb3Iocj1KLklUKHQuVS5hKGEpKTtyLkYoKTspcy5wdXNoKFUuTmYo
-ci5nbCgpKSl9cmV0dXJuIHN9LApOZjpmdW5jdGlvbihhKXt2YXIgcz1KLlU2KGEpLHI9SC5oKHMucShh
-LCJkZXNjcmlwdGlvbiIpKSxxPUguVk0oW10sdC5hSikKZm9yKHM9Si5JVCh0LlUuYShzLnEoYSwiZW50
-cmllcyIpKSk7cy5GKCk7KXEucHVzaChVLlJqKHMuZ2woKSkpCnJldHVybiBuZXcgVS55RChyLHEpfSwK
-Umo6ZnVuY3Rpb24oYSl7dmFyIHMscj1KLlU2KGEpLHE9SC5oKHIucShhLCJkZXNjcmlwdGlvbiIpKSxw
-PUguaChyLnEoYSwiZnVuY3Rpb24iKSksbz1yLnEoYSwibGluayIpCmlmKG89PW51bGwpbz1udWxsCmVs
-c2V7cz1KLlU2KG8pCm89bmV3IFUuTWwoSC5oKHMucShvLCJocmVmIikpLEgudVAocy5xKG8sImxpbmUi
-KSksSC5oKHMucShvLCJwYXRoIikpKX1yPXQuZksuYShyLnEoYSwiaGludEFjdGlvbnMiKSkKcj1yPT1u
-dWxsP251bGw6Si5NMShyLG5ldyBVLmFOKCksdC5hWCkKcj1yPT1udWxsP251bGw6ci5icigwKQpyZXR1
-cm4gbmV3IFUud2IocSxwLG8scj09bnVsbD9DLmRuOnIpfSwKZDI6ZnVuY3Rpb24gZDIoYSxiLGMsZCxl
-LGYpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5mPWZ9LApTZTpmdW5j
-dGlvbiBTZShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKTWw6ZnVuY3Rpb24gTWwoYSxiLGMpe3RoaXMu
-YT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKeUQ6ZnVuY3Rpb24geUQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
-Yn0sCndiOmZ1bmN0aW9uIHdiKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5k
-PWR9LAphTjpmdW5jdGlvbiBhTigpe30sCmIwOmZ1bmN0aW9uIGIwKCl7fX0sQj17CndSOmZ1bmN0aW9u
-KCl7cmV0dXJuIG5ldyBCLnFwKCIiLCIiLCIiLEMuRHgpfSwKWWY6ZnVuY3Rpb24oYSl7dmFyIHMscixx
-LHAsbyxuLG0sbCxrPUguaChhLnEoMCwicmVnaW9ucyIpKSxqPUguaChhLnEoMCwibmF2aWdhdGlvbkNv
-bnRlbnQiKSksaT1ILmgoYS5xKDAsInNvdXJjZUNvZGUiKSksaD1QLkZsKHQuWCx0LmRfKQpmb3Iocz10
-LnQuYShhLnEoMCwiZWRpdHMiKSkscz1zLmdQdShzKSxzPXMuZ20ocykscj10LlUscT10Lmg0O3MuRigp
-Oyl7cD1zLmdsKCkKbz1wLmEKbj1ILlZNKFtdLHEpCmZvcihwPUouSVQoci5hKHAuYikpO3AuRigpOyl7
-bT1wLmdsKCkKbD1KLlU2KG0pCm4ucHVzaChuZXcgQi5qOChILnVQKGwucShtLCJsaW5lIikpLEguaChs
-LnEobSwiZXhwbGFuYXRpb24iKSksSC51UChsLnEobSwib2Zmc2V0IikpKSl9aC5ZNSgwLG8sbil9cmV0
-dXJuIG5ldyBCLnFwKGssaixpLGgpfSwKajg6ZnVuY3Rpb24gajgoYSxiLGMpe3RoaXMuYT1hCnRoaXMu
-Yj1iCnRoaXMuYz1jfSwKcXA6ZnVuY3Rpb24gcXAoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9
-YgpfLmM9YwpfLmQ9ZH0sCmZ2OmZ1bmN0aW9uIGZ2KCl7fSwKT1M6ZnVuY3Rpb24oYSl7dmFyIHMKaWYo
-IShhPj02NSYmYTw9OTApKXM9YT49OTcmJmE8PTEyMgplbHNlIHM9ITAKcmV0dXJuIHN9LApZdTpmdW5j
-dGlvbihhLGIpe3ZhciBzPWEubGVuZ3RoLHI9YisyCmlmKHM8cilyZXR1cm4hMQppZighQi5PUyhDLnhC
-Lk8oYSxiKSkpcmV0dXJuITEKaWYoQy54Qi5PKGEsYisxKSE9PTU4KXJldHVybiExCmlmKHM9PT1yKXJl
-dHVybiEwCnJldHVybiBDLnhCLk8oYSxyKT09PTQ3fX0sVD17bVE6ZnVuY3Rpb24gbVEoKXt9fSxMPXsK
-SXE6ZnVuY3Rpb24oKXtDLkJaLkIoZG9jdW1lbnQsIkRPTUNvbnRlbnRMb2FkZWQiLG5ldyBMLmUoKSkK
-Qy5vbC5CKHdpbmRvdywicG9wc3RhdGUiLG5ldyBMLkwoKSl9LAprejpmdW5jdGlvbihhKXt2YXIgcyxy
-PXQuZy5hKGEucGFyZW50Tm9kZSkucXVlcnlTZWxlY3RvcigiOnNjb3BlID4gdWwiKSxxPXIuc3R5bGUs
-cD0iIitDLkNELnpRKHIub2Zmc2V0SGVpZ2h0KSoyKyJweCIKcS5tYXhIZWlnaHQ9cApxPUoucUYoYSkK
-cD1xLiR0aQpzPXAuQygifigxKT8iKS5hKG5ldyBMLld4KHIsYSkpCnQuWi5hKG51bGwpClcuSkUocS5h
-LHEuYixzLCExLHAuYyl9LAp5WDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtPSJxdWVyeVNl
-bGVjdG9yQWxsIixsPWRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoYSksaz10LmcKbC50b1N0cmluZwpzPXQu
-aApILkRoKGsscywiVCIsbSkKcj10LlIKcT1uZXcgVy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5uYXYt
-bGluayIpLHIpCnEuSyhxLG5ldyBMLkFPKGIpKQpILkRoKGsscywiVCIsbSkKcD1uZXcgVy53eihsLnF1
-ZXJ5U2VsZWN0b3JBbGwoIi5yZWdpb24iKSxyKQppZighcC5nbDAocCkpe289bC5xdWVyeVNlbGVjdG9y
-KCJ0YWJsZVtkYXRhLXBhdGhdIikKby50b1N0cmluZwpwLksocCxuZXcgTC5IbyhvLmdldEF0dHJpYnV0
-ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KG8pKS5PVSgicGF0aCIpKSkpfUguRGgoayxzLCJUIixt
-KQpuPW5ldyBXLnd6KGwucXVlcnlTZWxlY3RvckFsbCgiLmFkZC1oaW50LWxpbmsiKSxyKQpuLksobixu
-ZXcgTC5JQygpKX0sClE2OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1uZXcgWE1MSHR0cFJlcXVlc3QoKQpD
-LkR0LmVvKHMsIkdFVCIsTC5RNChhLGIpLCEwKQpzLnNldFJlcXVlc3RIZWFkZXIoIkNvbnRlbnQtVHlw
-ZSIsImFwcGxpY2F0aW9uL2pzb247IGNoYXJzZXQ9VVRGLTgiKQpyZXR1cm4gTC5MVShzLG51bGwsYy5D
-KCIwKiIpKX0sCnR5OmZ1bmN0aW9uKGEsYil7dmFyIHM9bmV3IFhNTEh0dHBSZXF1ZXN0KCkscj10LlgK
-Qy5EdC5lbyhzLCJQT1NUIixMLlE0KGEsUC5GbChyLHIpKSwhMCkKcy5zZXRSZXF1ZXN0SGVhZGVyKCJD
-b250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9qc29uOyBjaGFyc2V0PVVURi04IikKcmV0dXJuIEwuTFUo
-cyxiLHQudCl9LApMVTpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIEwuVGcoYSxiLGMsYy5DKCIwKiIpKX0s
-ClRnOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzPTAscj1QLkZYKGQpLHEscD0yLG8sbj1bXSxtLGwsayxq
-LGksaCxnLGYKdmFyICRhc3luYyRMVT1QLmx6KGZ1bmN0aW9uKGUsYTApe2lmKGU9PT0xKXtvPWEwCnM9
-cH13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6aT1uZXcgUC5aZihuZXcgUC52cygkLlgzLHQuZ1Yp
-LHQuYkMpCmg9dC5lYgpnPWguYShuZXcgTC5mQyhpLGEpKQp0LlouYShudWxsKQpsPXQuZVEKVy5KRShh
-LCJsb2FkIixnLCExLGwpClcuSkUoYSwiZXJyb3IiLGguYShpLmdZSigpKSwhMSxsKQphLnNlbmQoYj09
-bnVsbD9udWxsOkMuQ3QuT0IoYixudWxsKSkKcD00CnM9NwpyZXR1cm4gUC5qUShpLmEsJGFzeW5jJExV
-KQpjYXNlIDc6cD0yCnM9NgpicmVhawpjYXNlIDQ6cD0zCmY9bwpILlJ1KGYpCm09SC50cyhmKQpoPVAu
-VGwoIkVycm9yIHJlYWNoaW5nIG1pZ3JhdGlvbiBwcmV2aWV3IHNlcnZlci4iLG0pCnRocm93IEguYiho
-KQpzPTYKYnJlYWsKY2FzZSAzOnM9MgpicmVhawpjYXNlIDY6aj1DLkN0LnBXKDAsYS5yZXNwb25zZVRl
-eHQsbnVsbCkKaWYoYS5zdGF0dXM9PT0yMDApe3E9Yy5DKCIwKiIpLmEoaikKcz0xCmJyZWFrfWVsc2Ug
-dGhyb3cgSC5iKGopCmNhc2UgMTpyZXR1cm4gUC55QyhxLHIpCmNhc2UgMjpyZXR1cm4gUC5mMyhvLHIp
-fX0pCnJldHVybiBQLkRJKCRhc3luYyRMVSxyKX0sCmFLOmZ1bmN0aW9uKGEpe3ZhciBzPVAuaEsoYSku
-Z2hZKCkucSgwLCJsaW5lIikKcmV0dXJuIHM9PW51bGw/bnVsbDpILkhwKHMsbnVsbCl9LApHNjpmdW5j
-dGlvbihhKXt2YXIgcz1QLmhLKGEpLmdoWSgpLnEoMCwib2Zmc2V0IikKcmV0dXJuIHM9PW51bGw/bnVs
-bDpILkhwKHMsbnVsbCl9LAppNjpmdW5jdGlvbihhKXtyZXR1cm4gTC5uVyh0Lk8uYShhKSl9LApuVzpm
-dW5jdGlvbihhKXt2YXIgcz0wLHI9UC5GWCh0LnopLHE9MSxwLG89W10sbixtLGwsayxqLGksaAp2YXIg
-JGFzeW5jJGk2PVAubHooZnVuY3Rpb24oYixjKXtpZihiPT09MSl7cD1jCnM9cX13aGlsZSh0cnVlKXN3
-aXRjaChzKXtjYXNlIDA6aT10LmcuYShXLnFjKGEuY3VycmVudFRhcmdldCkpLmdldEF0dHJpYnV0ZSgi
-aHJlZiIpCmEucHJldmVudERlZmF1bHQoKQpxPTMKaz1kb2N1bWVudApuPUMuQ0QuelEoay5xdWVyeVNl
-bGVjdG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkKcz02CnJldHVybiBQLmpRKEwudHkoaSxudWxsKSwk
-YXN5bmMkaTYpCmNhc2UgNjpzPTcKcmV0dXJuIFAualEoTC5HNyh3aW5kb3cubG9jYXRpb24ucGF0aG5h
-bWUsbnVsbCxudWxsLCExLG51bGwpLCRhc3luYyRpNikKY2FzZSA3Oms9ay5xdWVyeVNlbGVjdG9yKCIu
-Y29udGVudCIpCmsudG9TdHJpbmcKay5zY3JvbGxUb3A9Si5WdShuKQpxPTEKcz01CmJyZWFrCmNhc2Ug
-MzpxPTIKaD1wCm09SC5SdShoKQpsPUgudHMoaCkKTC5DMigiQ291bGQgbm90IGFkZC9yZW1vdmUgaGlu
-dCIsbSxsKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxy
-KQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkaTYscil9LApDMjpm
-dW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHA9ImV4Y2VwdGlvbiIsbz0ic3RhY2tUcmFjZSIsbj10LnQu
-YihiKSYmSi5STShiLnEoMCwic3VjY2VzcyIpLCExKSYmYi54NChwKSYmYi54NChvKSxtPUouaWEoYikK
-aWYobil7cz1ILmgobS5xKGIscCkpCmM9bS5xKGIsbyl9ZWxzZSBzPW0udyhiKQpuPWRvY3VtZW50CnI9
-bi5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIpCnIucXVlcnlTZWxlY3RvcigiaDIiKS5pbm5lclRl
-eHQ9YQpyLnF1ZXJ5U2VsZWN0b3IoInAiKS5pbm5lclRleHQ9cwpyLnF1ZXJ5U2VsZWN0b3IoInByZSIp
-LmlubmVyVGV4dD1KLmooYykKcT10LmRkLmEoci5xdWVyeVNlbGVjdG9yKCJhLmJvdHRvbSIpKTsocSYm
-Qy54bikuc0xVKHEsUC5YZCgiaHR0cHMiLCJnaXRodWIuY29tIiwiZGFydC1sYW5nL3Nkay9pc3N1ZXMv
-bmV3IixQLkVGKFsidGl0bGUiLCJDdXN0b21lci1yZXBvcnRlZCBpc3N1ZSB3aXRoIE5OQkQgbWlncmF0
-aW9uIHRvb2w6ICIrYSwibGFiZWxzIix1LmQsImJvZHkiLGErIlxuXG5FcnJvcjogIitILkVqKHMpKyJc
-blxuUGxlYXNlIGZpbGwgaW4gdGhlIGZvbGxvd2luZzpcblxuKipOYW1lIG9mIHBhY2thZ2UgYmVpbmcg
-bWlncmF0ZWQgKGlmIHB1YmxpYykqKjpcbioqV2hhdCBJIHdhcyBkb2luZyB3aGVuIHRoaXMgaXNzdWUg
-b2NjdXJyZWQqKjpcbioqSXMgaXQgcG9zc2libGUgdG8gd29yayBhcm91bmQgdGhpcyBpc3N1ZSoqOlxu
-KipIYXMgdGhpcyBpc3N1ZSBoYXBwZW5lZCBiZWZvcmUsIGFuZCBpZiBzbywgaG93IG9mdGVuKio6XG4q
-KkRhcnQgU0RLIHZlcnNpb24qKjogIitILkVqKG4uZ2V0RWxlbWVudEJ5SWQoInNkay12ZXJzaW9uIiku
-dGV4dENvbnRlbnQpKyJcbioqQWRkaXRpb25hbCBkZXRhaWxzKio6XG5cblRoYW5rcyBmb3IgZmlsaW5n
-IVxuXG5TdGFja3RyYWNlOiBfYXV0byBwb3B1bGF0ZWQgYnkgbWlncmF0aW9uIHByZXZpZXcgdG9vbC5f
-XG5cbmBgYFxuIitILkVqKGMpKyJcbmBgYFxuIl0sdC5YLHQueikpLmduRCgpKQpuPXEuc3R5bGUKbi5k
-aXNwbGF5PSJpbml0aWFsIgpuPXIuc3R5bGUKbi5kaXNwbGF5PSJpbml0aWFsIgpuPWErIjogIitILkVq
-KGIpCndpbmRvdwppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJy
-b3IobikKd2luZG93Cm49SC5FaihjKQppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93
-LmNvbnNvbGUuZXJyb3Iobil9LAp0MjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG89dC5nLmEoVy5x
-YyhhLmN1cnJlbnRUYXJnZXQpKQphLnByZXZlbnREZWZhdWx0KCkKcz1vLmdldEF0dHJpYnV0ZSgiaHJl
-ZiIpCnI9TC5VcyhzKQpxPUwuRzYocykKcD1MLmFLKHMpCmlmKHEhPW51bGwpTC5hZihyLHEscCxiLG5l
-dyBMLm5UKHIscSxwKSkKZWxzZSBMLmFmKHIsbnVsbCxudWxsLGIsbmV3IEwuTlkocikpfSwKSzA6ZnVu
-Y3Rpb24oYSl7dmFyIHMscixxLHA9ZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKQpw
-LnF1ZXJ5U2VsZWN0b3IoImgyIikuaW5uZXJUZXh0PSJGYWlsZWQgdG8gcmVydW4gZnJvbSBzb3VyY2Vz
-IgpwLnF1ZXJ5U2VsZWN0b3IoInAiKS5pbm5lclRleHQ9IlNvdXJjZXMgY29udGFpbiBzdGF0aWMgYW5h
-bHlzaXMgZXJyb3JzOiIKcz1wLnF1ZXJ5U2VsZWN0b3IoInByZSIpCnI9Si5FbChhLHQuYXcpCnE9SC5M
-aChyKQpzLmlubmVyVGV4dD1uZXcgSC5sSihyLHEuQygicVUqKGxELkUpIikuYShuZXcgTC51ZSgpKSxx
-LkMoImxKPGxELkUscVUqPiIpKS5rKDAsIlxuIikKcT1wLnF1ZXJ5U2VsZWN0b3IoImEuYm90dG9tIiku
-c3R5bGUKcS5kaXNwbGF5PSJub25lIgpzPXAuc3R5bGUKcy5kaXNwbGF5PSJpbml0aWFsIn0sCnZVOmZ1
-bmN0aW9uKCl7dmFyIHM9ZG9jdW1lbnQKSC5EaCh0LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFsbCIp
-CnM9bmV3IFcud3oocy5xdWVyeVNlbGVjdG9yQWxsKCIuY29kZSIpLHQuUikKcy5LKHMsbmV3IEwuZVgo
-KSl9LApoWDpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIEwuWXcoYSxiLGMpfSwKWXc6ZnVuY3Rpb24oYSxi
-LGMpe3ZhciBzPTAscj1QLkZYKHQueikscT0xLHAsbz1bXSxuLG0sbCxrLGosaSxoLGcKdmFyICRhc3lu
-YyRoWD1QLmx6KGZ1bmN0aW9uKGQsZSl7aWYoZD09PTEpe3A9ZQpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2go
-cyl7Y2FzZSAwOnE9MwpqPXQuWApzPTYKcmV0dXJuIFAualEoTC5RNihhLFAuRUYoWyJyZWdpb24iLCJy
-ZWdpb24iLCJvZmZzZXQiLEguRWooYildLGosaiksdC50KSwkYXN5bmMkaFgpCmNhc2UgNjpuPWUKaj1u
-Cmk9Si5VNihqKQptPW5ldyBVLmQyKFUuamYoaS5xKGosImVkaXRzIikpLEguaChpLnEoaiwiZXhwbGFu
-YXRpb24iKSksSC51UChpLnEoaiwibGluZSIpKSxILmgoaS5xKGosImRpc3BsYXlQYXRoIikpLEguaChp
-LnEoaiwidXJpUGF0aCIpKSxVLk5kKGkucShqLCJ0cmFjZXMiKSkpCkwuVDEobSkKTC5GcihhLGIsYykK
-TC55WCgiLmVkaXQtcGFuZWwgLnBhbmVsLWNvbnRlbnQiLCExKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpx
-PTIKZz1wCmw9SC5SdShnKQprPUgudHMoZykKTC5DMigiQ291bGQgbm90IGxvYWQgZWRpdCBkZXRhaWxz
-IixsLGspCnM9NQpicmVhawpjYXNlIDI6cz0xCmJyZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIp
-CmNhc2UgMTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRoWCxyKX0sCkc3OmZ1
-bmN0aW9uKGEsYixjLGQsZSl7cmV0dXJuIEwuTDUoYSxiLGMsZCxlKX0sCkw1OmZ1bmN0aW9uKGEsYixj
-LGQsZSl7dmFyIHM9MCxyPVAuRlgodC5IKSxxLHA9MixvLG49W10sbSxsLGssaixpLGgsZwp2YXIgJGFz
-eW5jJEc3PVAubHooZnVuY3Rpb24oZixhMCl7aWYoZj09PTEpe289YTAKcz1wfXdoaWxlKHRydWUpc3dp
-dGNoKHMpe2Nhc2UgMDppZighSi5wNChhLCIuZGFydCIpKXtMLkJFKGEsQi53UigpLGQpCkwuQlgoYSxu
-dWxsKQppZihlIT1udWxsKWUuJDAoKQpzPTEKYnJlYWt9cD00Cmk9dC5YCnM9NwpyZXR1cm4gUC5qUShM
-LlE2KGEsUC5FRihbImlubGluZSIsInRydWUiXSxpLGkpLHQudCksJGFzeW5jJEc3KQpjYXNlIDc6bT1h
-MApMLkJFKGEsQi5ZZihtKSxkKQpMLmZHKGIsYykKbD1MLlVzKGEpCkwuQlgobCxiKQppZihlIT1udWxs
-KWUuJDAoKQpwPTIKcz02CmJyZWFrCmNhc2UgNDpwPTMKZz1vCms9SC5SdShnKQpqPUgudHMoZykKTC5D
-MigiQ291bGQgbm90IGxvYWQgZGFydCBmaWxlICIrYSxrLGopCnM9NgpicmVhawpjYXNlIDM6cz0yCmJy
-ZWFrCmNhc2UgNjpjYXNlIDE6cmV0dXJuIFAueUMocSxyKQpjYXNlIDI6cmV0dXJuIFAuZjMobyxyKX19
-KQpyZXR1cm4gUC5ESSgkYXN5bmMkRzcscil9LApHZTpmdW5jdGlvbigpe3ZhciBzPTAscj1QLkZYKHQu
-eikscT0xLHAsbz1bXSxuLG0sbCxrLGosaSxoLGcKdmFyICRhc3luYyRHZT1QLmx6KGZ1bmN0aW9uKGEs
-Yil7aWYoYT09PTEpe3A9YgpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOmg9Ii9fcHJldmll
-dy9uYXZpZ2F0aW9uVHJlZS5qc29uIgpxPTMKcz02CnJldHVybiBQLmpRKEwuUTYoaCxDLkNNLHQuZUUp
-LCRhc3luYyRHZSkKY2FzZSA2Om49YgptPWRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIi5uYXYtdHJlZSIp
-CkoubDUobSwiIikKaj1MLm1LKG4pCiQuSVI9agpMLnRYKG0saiwhMCkKcT0xCnM9NQpicmVhawpjYXNl
-IDM6cT0yCmc9cApsPUguUnUoZykKaz1ILnRzKGcpCkwuQzIoIkNvdWxkIG5vdCBsb2FkIG5hdmlnYXRp
-b24gdHJlZSIsbCxrKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMo
-bnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkR2Uscil9
-LApxTzpmdW5jdGlvbihhKXt2YXIgcyxyPWEuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkscT1DLkNELnpR
-KCQuZmkoKS5vZmZzZXRIZWlnaHQpLHA9d2luZG93LmlubmVySGVpZ2h0LG89Qy5DRC56USgkLkRXKCku
-b2Zmc2V0SGVpZ2h0KQppZih0eXBlb2YgcCE9PSJudW1iZXIiKXJldHVybiBwLkhOKCkKcz1yLmJvdHRv
-bQpzLnRvU3RyaW5nCmlmKHM+cC0obysxNCkpSi5kaChhKQplbHNle3A9ci50b3AKcC50b1N0cmluZwpp
-ZihwPHErMTQpSi5kaChhKX19LApmRzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8KaWYoYSE9bnVs
-bCl7cz1kb2N1bWVudApyPXMuZ2V0RWxlbWVudEJ5SWQoIm8iK0guRWooYSkpCnE9cy5xdWVyeVNlbGVj
-dG9yKCIubGluZS0iK0guRWooYikpCmlmKHIhPW51bGwpe0wucU8ocikKSi5kUihyKS5pKDAsInRhcmdl
-dCIpfWVsc2UgaWYocSE9bnVsbClMLnFPKHEucGFyZW50RWxlbWVudCkKaWYocSE9bnVsbClKLmRSKHQu
-Zy5hKHEucGFyZW50Tm9kZSkpLmkoMCwiaGlnaGxpZ2h0Iil9ZWxzZXtzPWRvY3VtZW50CnA9dC5nCkgu
-RGgocCx0LmgsIlQiLCJxdWVyeVNlbGVjdG9yQWxsIikKcz1zLnF1ZXJ5U2VsZWN0b3JBbGwoIi5saW5l
-LW5vIikKbz1uZXcgVy53eihzLHQuUikKaWYoby5nQShvKT09PTApcmV0dXJuCkwucU8ocC5hKEMudDUu
-Z3RIKHMpKSl9fSwKYWY6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHE9TC5HNih3aW5kb3cubG9j
-YXRpb24uaHJlZikscD1MLmFLKHdpbmRvdy5sb2NhdGlvbi5ocmVmKQppZihxIT1udWxsKXtzPWRvY3Vt
-ZW50LmdldEVsZW1lbnRCeUlkKCJvIitILkVqKHEpKQppZihzIT1udWxsKUouZFIocykuUigwLCJ0YXJn
-ZXQiKX1pZihwIT1udWxsKXtyPWRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIi5saW5lLSIrSC5FaihwKSkK
-aWYociE9bnVsbClKLmRSKHIucGFyZW50RWxlbWVudCkuUigwLCJoaWdobGlnaHQiKX1pZihhPT13aW5k
-b3cubG9jYXRpb24ucGF0aG5hbWUpe0wuZkcoYixjKQplLiQwKCl9ZWxzZSBMLkc3KGEsYixjLGQsZSl9
-LApRNDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1QLmhLKGEpLHA9dC5YCnA9UC5GbChwLHApCmZvcihz
-PXEuZ2hZKCkscz1zLmdQdShzKSxzPXMuZ20ocyk7cy5GKCk7KXtyPXMuZ2woKQpwLlk1KDAsci5hLHIu
-Yil9Zm9yKHM9Yi5nUHUoYikscz1zLmdtKHMpO3MuRigpOyl7cj1zLmdsKCkKcC5ZNSgwLHIuYSxyLmIp
-fXAuWTUoMCwiYXV0aFRva2VuIiwkLlVFKCkpCnJldHVybiBxLm5tKDAscCkuZ25EKCl9LApUMTpmdW5j
-dGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaj0kLmhMKCkKSi5sNShqLCIiKQppZihhPT1udWxs
-KXtzPWRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInAiKQpDLkx0LnNhNChzLCJTZWUgZGV0YWlscyBhYm91
-dCBhIHByb3Bvc2VkIGVkaXQuIikKQy5MdC5zUChzLEguVk0oWyJwbGFjZWhvbGRlciJdLHQuaSkpCmou
-YXBwZW5kQ2hpbGQocykKQy5MdC5GRihzKQpyZXR1cm59cj1hLmQKcT0kLm5VKCkKcD1xLnpmKHIpCm89
-YS5iCm49ZG9jdW1lbnQKbT1xLkhQKHIsSi5UMChuLnF1ZXJ5U2VsZWN0b3IoIi5yb290IikudGV4dENv
-bnRlbnQpKQpsPWEuYwprPW4uY3JlYXRlRWxlbWVudCgicCIpCmouYXBwZW5kQ2hpbGQoaykKay5hcHBl
-bmRDaGlsZChuLmNyZWF0ZVRleHROb2RlKEguRWoobykrIiBhdCAiKSkKcT10LlgKcT1XLko2KEwuUTQo
-YS5lLFAuRUYoWyJsaW5lIixKLmoobCldLHEscSkpKQpxLmFwcGVuZENoaWxkKG4uY3JlYXRlVGV4dE5v
-ZGUoSC5FaihtKSsiOiIrSC5FaihsKSsiLiIpKQprLmFwcGVuZENoaWxkKHEpCkouZGgoaykKTC5DQyhh
-LGoscCkKTC5GeihhLGopfSwKTEg6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwLG8sbixtLGwsayxq
-LGksaCxnLGYsZT0kLnlQKCkKSi5sNShlLCIiKQppZihiLmdBKGIpPT09MCl7cz1kb2N1bWVudApyPXMu
-Y3JlYXRlRWxlbWVudCgicCIpCmUuYXBwZW5kQ2hpbGQocikKci5hcHBlbmRDaGlsZChzLmNyZWF0ZVRl
-eHROb2RlKCJObyBwcm9wb3NlZCBlZGl0cyIpKX1lbHNlIGZvcihlPWIuZ1B1KGIpLGU9ZS5nbShlKSxz
-PXQuWCxxPXQuayxwPXEuQygifigxKT8iKSxvPXQuWixxPXEuYztlLkYoKTspe249ZS5nbCgpCm09ZG9j
-dW1lbnQKcj1tLmNyZWF0ZUVsZW1lbnQoInAiKQpsPSQueVAoKQpsLmFwcGVuZENoaWxkKHIpCnIuYXBw
-ZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZShILkVqKG4uYSkrIjoiKSkKaz1tLmNyZWF0ZUVsZW1lbnQo
-InVsIikKbC5hcHBlbmRDaGlsZChrKQpmb3Iobj1KLklUKG4uYik7bi5GKCk7KXtsPW4uZ2woKQpqPW0u
-Y3JlYXRlRWxlbWVudCgibGkiKQprLmFwcGVuZENoaWxkKGopCkouZFIoaikuaSgwLCJlZGl0IikKaT1t
-LmNyZWF0ZUVsZW1lbnQoImEiKQpqLmFwcGVuZENoaWxkKGkpCmkuY2xhc3NMaXN0LmFkZCgiZWRpdC1s
-aW5rIikKaD1sLmMKZz1ILkVqKGgpCmkuc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcu
-aTcoaSkpLk9VKCJvZmZzZXQiKSxnKQpmPWwuYQpnPUguRWooZikKaS5zZXRBdHRyaWJ1dGUoImRhdGEt
-IituZXcgVy5TeShuZXcgVy5pNyhpKSkuT1UoImxpbmUiKSxnKQppLmFwcGVuZENoaWxkKG0uY3JlYXRl
-VGV4dE5vZGUoImxpbmUgIitILkVqKGYpKSkKaS5zZXRBdHRyaWJ1dGUoImhyZWYiLEwuUTQod2luZG93
-LmxvY2F0aW9uLnBhdGhuYW1lLFAuRUYoWyJsaW5lIixILkVqKGYpLCJvZmZzZXQiLEguRWooaCldLHMs
-cykpKQpnPXAuYShuZXcgTC5FRShoLGYsYSkpCm8uYShudWxsKQpXLkpFKGksImNsaWNrIixnLCExLHEp
-CmouYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiK0guRWoobC5iKSkpfX1pZihjKUwuVDEo
-bnVsbCl9LApGcjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxPXdpbmRvdy5sb2NhdGlvbixwPVAuaEso
-KHEmJkMuRXgpLmdEcihxKStILkVqKGEpKQpxPXQuWApxPVAuRmwocSxxKQppZihiIT1udWxsKXEuWTUo
-MCwib2Zmc2V0IixILkVqKGIpKQppZihjIT1udWxsKXEuWTUoMCwibGluZSIsSC5FaihjKSkKcS5ZNSgw
-LCJhdXRoVG9rZW4iLCQuVUUoKSkKcD1wLm5tKDAscSkKcT13aW5kb3cuaGlzdG9yeQpzPXQuegpyPXAu
-Z25EKCkKcS50b1N0cmluZwpxLnB1c2hTdGF0ZShuZXcgUC5CZihbXSxbXSkuUHYoUC5GbChzLHMpKSwi
-IixyKX0sCkVuOmZ1bmN0aW9uKGEpe3ZhciBzPUouYmIoZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnJv
-b3QiKS50ZXh0Q29udGVudCwiLyIpCmlmKEMueEIubihhLHMpKXJldHVybiBDLnhCLnluKGEscy5sZW5n
-dGgpCmVsc2UgcmV0dXJuIGF9LApPdDpmdW5jdGlvbihhKXtzd2l0Y2goYS5yKXtjYXNlIEMuY3c6YnJl
-YWsKY2FzZSBDLldEOmEucj1DLlhqCmJyZWFrCmNhc2UgQy5YajphLnI9Qy5XRApicmVhawpjYXNlIEMu
-ZGM6dGhyb3cgSC5iKFAuUFYoIkZpbGUgIitILkVqKGEuYykrIiBzaG91bGQgbm90IGhhdmUgaW5kZXRl
-cm1pbmF0ZSBtaWdyYXRpb24gc3RhdHVzIikpfX0sCnhuOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPSJk
-aXNhYmxlZCIscD1iLmdMKCkKTC50YShhLHApCmlmKGIuYz09JC5EOSgpLmlubmVyVGV4dCl7cz1iIGlu
-c3RhbmNlb2YgTC5jRCYmIUgub1QoYi54KQpyPUouWUUoYSkKaWYocylyLmdQKGEpLmkoMCxxKQplbHNl
-IHIuZ1AoYSkuUigwLHEpCkwudGEoJC5jMCgpLHApfX0sCnRhOmZ1bmN0aW9uKGEsYil7dmFyIHMscj0i
-Y2hlY2tfYm94IixxPSJ0aXRsZSIscD0ib3B0ZWQtb3V0IixvPSJtaWdyYXRpbmciCnN3aXRjaChiKXtj
-YXNlIEMuY3c6YS5pbm5lclRleHQ9cgpzPUouWUUoYSkKcy5nUChhKS5pKDAsImFscmVhZHktbWlncmF0
-ZWQiKQpzLmdQKGEpLmkoMCwiZGlzYWJsZWQiKQphLnNldEF0dHJpYnV0ZShxLCJBbHJlYWR5IG1pZ3Jh
-dGVkIikKYnJlYWsKY2FzZSBDLldEOmEuaW5uZXJUZXh0PXIKcz1KLllFKGEpCnMuZ1AoYSkuUigwLHAp
-CnMuZ1AoYSkuaSgwLG8pCmEuc2V0QXR0cmlidXRlKHEsIk1pZ3JhdGluZyB0byBudWxsIHNhZmV0eSIp
-CmJyZWFrCmNhc2UgQy5YajphLmlubmVyVGV4dD0iY2hlY2tfYm94X291dGxpbmVfYmxhbmsiCnM9Si5Z
-RShhKQpzLmdQKGEpLlIoMCxvKQpzLmdQKGEpLmkoMCxwKQphLnNldEF0dHJpYnV0ZShxLCJPcHRpbmcg
-b3V0IG9mIG51bGwgc2FmZXR5IikKYnJlYWsKZGVmYXVsdDphLmlubmVyVGV4dD0iaW5kZXRlcm1pbmF0
-ZV9jaGVja19ib3giCnM9Si5ZRShhKQpzLmdQKGEpLlIoMCxvKQpzLmdQKGEpLmkoMCxwKQphLnNldEF0
-dHJpYnV0ZShxLCJNaXhlZCBzdGF0dXNlcyBvZiAnbWlncmF0aW5nJyBhbmQgJ29wdGluZyBvdXQnIikK
-YnJlYWt9fSwKQlg6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9e30KcS5hPWEKYT1MLkVuKGEpCnEuYT1h
-CkouZHIoJC5EOSgpLGEpCnM9ZG9jdW1lbnQKSC5EaCh0LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFs
-bCIpCnM9bmV3IFcud3oocy5xdWVyeVNlbGVjdG9yQWxsKCIubmF2LXBhbmVsIC5uYXYtbGluayIpLHQu
-UikKcy5LKHMsbmV3IEwuVlMocSkpCnI9TC5tSCgkLklSLHEuYSkKaWYocj09bnVsbClKLmRSKCQuYk4o
-KSkuUigwLCJ2aXNpYmxlIikKZWxzZXtKLmRSKCQuYk4oKSkuaSgwLCJ2aXNpYmxlIikKTC50YSgkLmMw
-KCksci5nTCgpKX19LApBUjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1iLmIKaWYocSE9bnVsbCl7cz10
-LmcKcj1zLmEocy5hKGEucGFyZW50Tm9kZSkucGFyZW50Tm9kZSkKTC54bihyLnF1ZXJ5U2VsZWN0b3Io
-IjpzY29wZSA+IC5zdGF0dXMtaWNvbiIpLHEpCkwuQVIocixxKX19LApobDpmdW5jdGlvbihhLGIpe3Zh
-ciBzLHIscSxwLG8sbixtPSI6c2NvcGUgPiAuc3RhdHVzLWljb24iCmZvcihzPWIuZCxyPXMubGVuZ3Ro
-LHE9dC5nLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytwKXtvPXNbcF0K
-bj1hLnF1ZXJ5U2VsZWN0b3IoJ1tkYXRhLW5hbWUqPSInK0guRWooby5jKSsnIl0nKQppZihvIGluc3Rh
-bmNlb2YgTC52dCl7TC5obChuLG8pCkwueG4obi5xdWVyeVNlbGVjdG9yKG0pLGIpfWVsc2UgTC54bihx
-LmEobi5wYXJlbnROb2RlKS5xdWVyeVNlbGVjdG9yKG0pLG8pfX0sCkJFOmZ1bmN0aW9uKGEsYixjKXt2
-YXIgcz0iLnJlZ2lvbnMiLHI9ZG9jdW1lbnQscT1yLnF1ZXJ5U2VsZWN0b3IocykscD1yLnF1ZXJ5U2Vs
-ZWN0b3IoIi5jb2RlIikKSi50SChxLGIuYSwkLktHKCkpCkoudEgocCxiLmIsJC5LRygpKQpMLkxIKGEs
-Yi5kLGMpCmlmKGIuYy5sZW5ndGg8MmU1KUwudlUoKQpMLnlYKCIuY29kZSIsITApCkwueVgocywhMCl9
-LAp0WDpmdW5jdGlvbihhMSxhMixhMyl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQs
-Yz0ibWF0ZXJpYWwtaWNvbnMiLGI9InN0YXR1cy1pY29uIixhPWRvY3VtZW50LGEwPWEuY3JlYXRlRWxl
-bWVudCgidWwiKQphMS5hcHBlbmRDaGlsZChhMCkKZm9yKHM9YTIubGVuZ3RoLHI9dC5YLHE9dC5aLHA9
-MDtwPGEyLmxlbmd0aDthMi5sZW5ndGg9PT1zfHwoMCxILmxrKShhMiksKytwKXtvPWEyW3BdCm49YS5j
-cmVhdGVFbGVtZW50KCJsaSIpCmEwLmFwcGVuZENoaWxkKG4pCmlmKG8gaW5zdGFuY2VvZiBMLnZ0KXtt
-PUouWUUobikKbS5nUChuKS5pKDAsImRpciIpCm4uc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3ko
-bmV3IFcuaTcobikpLk9VKCJuYW1lIiksby5jKQpsPWEuY3JlYXRlRWxlbWVudCgic3BhbiIpCm4uYXBw
-ZW5kQ2hpbGQobCkKaz1KLllFKGwpCmsuZ1AobCkuaSgwLCJhcnJvdyIpCmsuc2hmKGwsIiYjeDI1QkM7
-IikKaj1hLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpKLmRSKGopLmkoMCxjKQpqLmlubmVyVGV4dD0iZm9s
-ZGVyX29wZW4iCm4uYXBwZW5kQ2hpbGQoaikKbi5hcHBlbmRDaGlsZChhLmNyZWF0ZVRleHROb2RlKG8u
-YSkpCkwudFgobixvLmQsITApCmk9YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKaz1KLllFKGkpCmsuZ1Ao
-aSkuaSgwLGMpCmkuaW5uZXJUZXh0PSJpbmRldGVybWluYXRlX2NoZWNrX2JveCIKay5nUChpKS5pKDAs
-YikKTC54bihpLG8pCms9ay5nVmwoaSkKaD1rLiR0aQpnPWguQygifigxKT8iKS5hKG5ldyBMLlREKG8s
-bixpKSkKcS5hKG51bGwpClcuSkUoay5hLGsuYixnLCExLGguYykKbS5tSyhuLGksaikKTC5reihsKX1l
-bHNlIGlmKG8gaW5zdGFuY2VvZiBMLmNEKXtpPWEuY3JlYXRlRWxlbWVudCgic3BhbiIpCm09Si5ZRShp
-KQptLmdQKGkpLmkoMCxjKQppLmlubmVyVGV4dD0iIgptLmdQKGkpLmkoMCxiKQprPUgub1Qoby54KQpp
-ZighayltLmdQKGkpLmkoMCwiZGlzYWJsZWQiKQpMLnhuKGksbykKaWYoayl7bT1tLmdWbChpKQprPW0u
-JHRpCmg9ay5DKCJ+KDEpPyIpLmEobmV3IEwuSWYobyxpLG4pKQpxLmEobnVsbCkKVy5KRShtLmEsbS5i
-LGgsITEsay5jKX1uLmFwcGVuZENoaWxkKGkpCm09YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKSi5kUiht
-KS5pKDAsYykKbS5pbm5lclRleHQ9Imluc2VydF9kcml2ZV9maWxlIgpuLmFwcGVuZENoaWxkKG0pCmY9
-YS5jcmVhdGVFbGVtZW50KCJhIikKbi5hcHBlbmRDaGlsZChmKQptPUouWUUoZikKbS5nUChmKS5pKDAs
-Im5hdi1saW5rIikKZi5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhmKSkuT1Uo
-Im5hbWUiKSxvLmMpCmYuc2V0QXR0cmlidXRlKCJocmVmIixMLlE0KG8uZCxQLkZsKHIscikpKQpmLmFw
-cGVuZENoaWxkKGEuY3JlYXRlVGV4dE5vZGUoby5hKSkKbT1tLmdWbChmKQprPW0uJHRpCmg9ay5DKCJ+
-KDEpPyIpLmEobmV3IEwudEIoKSkKcS5hKG51bGwpClcuSkUobS5hLG0uYixoLCExLGsuYykKZT1vLmUK
-aWYodHlwZW9mIGUhPT0ibnVtYmVyIilyZXR1cm4gZS5vcygpCmlmKGU+MCl7ZD1hLmNyZWF0ZUVsZW1l
-bnQoInNwYW4iKQpuLmFwcGVuZENoaWxkKGQpCkouZFIoZCkuaSgwLCJlZGl0LWNvdW50IikKbT0iIitl
-KyIgIgppZihlPT09MSlrPSJwcm9wb3NlZCBlZGl0IgplbHNlIGs9InByb3Bvc2VkIGVkaXRzIgpkLnNl
-dEF0dHJpYnV0ZSgidGl0bGUiLG0raykKZC5hcHBlbmRDaGlsZChhLmNyZWF0ZVRleHROb2RlKEMuam4u
-dyhlKSkpfX19fSwKdXo6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPWRvY3VtZW50LHI9cy5jcmVhdGVFbGVt
-ZW50KCJidXR0b24iKSxxPXQuayxwPXEuQygifigxKT8iKS5hKG5ldyBMLm0yKGEsYykpCnQuWi5hKG51
-bGwpClcuSkUociwiY2xpY2siLHAsITEscS5jKQpyLmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUo
-TS5PWChhLmEpKSkKYi5hcHBlbmRDaGlsZChyKX0sCkZ6OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAs
-byxuLG0sbCxrLGosaSxoPWEuYQppZihoPT1udWxsKXJldHVybgpzPWRvY3VtZW50CnI9cy5jcmVhdGVF
-bGVtZW50KCJwIikKcT1iLmFwcGVuZENoaWxkKHIpCnI9cy5jcmVhdGVFbGVtZW50KCJzcGFuIikKcD10
-LmkKSi5NdShyLEguVk0oWyJ0eXBlLWRlc2NyaXB0aW9uIl0scCkpCnIuYXBwZW5kQ2hpbGQocy5jcmVh
-dGVUZXh0Tm9kZSgiQWN0aW9ucyIpKQpxLmFwcGVuZENoaWxkKHIpCnEuYXBwZW5kQ2hpbGQocy5jcmVh
-dGVUZXh0Tm9kZSgiOiIpKQpvPXMuY3JlYXRlRWxlbWVudCgicCIpCmIuYXBwZW5kQ2hpbGQobykKZm9y
-KHI9aC5sZW5ndGgsbj10LlEsbT0wO208aC5sZW5ndGg7aC5sZW5ndGg9PT1yfHwoMCxILmxrKShoKSwr
-K20pe2w9aFttXQprPXMuY3JlYXRlRWxlbWVudCgiYSIpCm8uYXBwZW5kQ2hpbGQoaykKay5hcHBlbmRD
-aGlsZChzLmNyZWF0ZVRleHROb2RlKGwuYSkpCmsuc2V0QXR0cmlidXRlKCJocmVmIixsLmIpCmo9bi5h
-KEguVk0oWyJhZGQtaGludC1saW5rIiwiYmVmb3JlLWFwcGx5IiwiYnV0dG9uIl0scCkpCmk9Si5kUihr
-KQppLlYxKDApCmkuRlYoMCxqKX19LApDQzpmdW5jdGlvbihhNCxhNSxhNil7dmFyIHMscixxLHAsbyxu
-LG0sbCxrLGosaSxoLGcsZixlLGQsYyxiLGEsYTAsYTEsYTIsYTMKZm9yKHM9YTQuZixyPXMubGVuZ3Ro
-LHE9dC5pLHA9dC5RLG89MDtvPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytvKXtu
-PXNbb10KbT1kb2N1bWVudApsPW0uY3JlYXRlRWxlbWVudCgicCIpCms9cC5hKEguVk0oWyJ0cmFjZSJd
-LHEpKQpqPUouZFIobCkKai5WMSgwKQpqLkZWKDAsaykKaT1hNS5hcHBlbmRDaGlsZChsKQpsPW0uY3Jl
-YXRlRWxlbWVudCgic3BhbiIpCms9cC5hKEguVk0oWyJ0eXBlLWRlc2NyaXB0aW9uIl0scSkpCmo9Si5k
-UihsKQpqLlYxKDApCmouRlYoMCxrKQpsLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUobi5hKSkK
-aS5hcHBlbmRDaGlsZChsKQppLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIjoiKSkKbD1tLmNy
-ZWF0ZUVsZW1lbnQoInVsIikKaz1wLmEoSC5WTShbInRyYWNlIl0scSkpCmo9Si5kUihsKQpqLlYxKDAp
-CmouRlYoMCxrKQpoPWkuYXBwZW5kQ2hpbGQobCkKZm9yKGw9bi5iLGs9bC5sZW5ndGgsZz0wO2c8bC5s
-ZW5ndGg7bC5sZW5ndGg9PT1rfHwoMCxILmxrKShsKSwrK2cpe2Y9bFtnXQplPW0uY3JlYXRlRWxlbWVu
-dCgibGkiKQpoLmFwcGVuZENoaWxkKGUpCmQ9bS5jcmVhdGVFbGVtZW50KCJzcGFuIikKYz1wLmEoSC5W
-TShbImZ1bmN0aW9uIl0scSkpCmo9Si5kUihkKQpqLlYxKDApCmouRlYoMCxjKQpjPWYuYgpMLmtEKGQs
-Yz09bnVsbD8idW5rbm93biI6YykKZS5hcHBlbmRDaGlsZChkKQpiPWYuYwppZihiIT1udWxsKXtlLmFw
-cGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIiAoIikpCmE9Yi5iCmEwPW0uY3JlYXRlRWxlbWVudCgi
-YSIpCmEwLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoSC5FaihiLmMpKyI6IitILkVqKGEpKSkK
-YTAuc2V0QXR0cmlidXRlKCJocmVmIixiLmEpCmEwLmNsYXNzTGlzdC5hZGQoIm5hdi1saW5rIikKZS5h
-cHBlbmRDaGlsZChhMCkKZS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKCIpIikpfWUuYXBwZW5k
-Q2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiKSkKZD1mLmEKTC5rRChlLGQ9PW51bGw/InVua25vd24i
-OmQpCmQ9Zi5kCmlmKGQubGVuZ3RoIT09MCl7Yz1tLmNyZWF0ZUVsZW1lbnQoInAiKQphMT1wLmEoSC5W
-TShbImRyYXdlciIsImJlZm9yZS1hcHBseSJdLHEpKQpqPUouZFIoYykKai5WMSgwKQpqLkZWKDAsYTEp
-CmEyPWUuYXBwZW5kQ2hpbGQoYykKZm9yKGM9ZC5sZW5ndGgsYTM9MDthMzxkLmxlbmd0aDtkLmxlbmd0
-aD09PWN8fCgwLEgubGspKGQpLCsrYTMpTC51eihkW2EzXSxhMixiKX19fX0sClVzOmZ1bmN0aW9uKGEp
-e3JldHVybiBKLlU2KGEpLnRnKGEsIj8iKT9DLnhCLk5qKGEsMCxDLnhCLk9ZKGEsIj8iKSk6YX0sCmtE
-OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPUguVk0oYi5zcGxpdCgiLiIpLHQucykscD1DLk5tLmd0SChx
-KSxvPWRvY3VtZW50CmEuYXBwZW5kQ2hpbGQoby5jcmVhdGVUZXh0Tm9kZShwKSkKZm9yKHA9SC5xQyhx
-LDEsbnVsbCx0Lk4pLHA9bmV3IEguYTcocCxwLmdBKHApLHAuJHRpLkMoImE3PGFMLkU+IikpLHM9Si5Z
-RShhKTtwLkYoKTspe3I9cC5kCnMubnooYSwiYmVmb3JlZW5kIiwiJiM4MjAzOy4iLG51bGwsbnVsbCkK
-YS5hcHBlbmRDaGlsZChvLmNyZWF0ZVRleHROb2RlKHIpKX19LAptSDpmdW5jdGlvbihhLGIpe3ZhciBz
-LHIscSxwCmZvcihzPWEubGVuZ3RoLHI9MDtyPGEubGVuZ3RoO2EubGVuZ3RoPT09c3x8KDAsSC5sayko
-YSksKytyKXtxPWFbcl0KaWYocSBpbnN0YW5jZW9mIEwudnQpe3A9TC5tSChxLmQsYikKaWYocCE9bnVs
-bClyZXR1cm4gcH1lbHNlIGlmKHEuYz09YilyZXR1cm4gcX1yZXR1cm4gbnVsbH0sCmU6ZnVuY3Rpb24g
-ZSgpe30sClZXOmZ1bmN0aW9uIFZXKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCm9a
-OmZ1bmN0aW9uIG9aKCl7fSwKanI6ZnVuY3Rpb24ganIoKXt9LApxbDpmdW5jdGlvbiBxbCgpe30sCkhp
-OmZ1bmN0aW9uIEhpKCl7fSwKQlQ6ZnVuY3Rpb24gQlQoKXt9LApQWTpmdW5jdGlvbiBQWSgpe30sCnU4
-OmZ1bmN0aW9uIHU4KCl7fSwKTDpmdW5jdGlvbiBMKCl7fSwKV3g6ZnVuY3Rpb24gV3goYSxiKXt0aGlz
-LmE9YQp0aGlzLmI9Yn0sCkFPOmZ1bmN0aW9uIEFPKGEpe3RoaXMuYT1hfSwKZE46ZnVuY3Rpb24gZE4o
-YSl7dGhpcy5hPWF9LApIbzpmdW5jdGlvbiBIbyhhKXt0aGlzLmE9YX0sCnh6OmZ1bmN0aW9uIHh6KGEs
-Yil7dGhpcy5hPWEKdGhpcy5iPWJ9LApJQzpmdW5jdGlvbiBJQygpe30sCmZDOmZ1bmN0aW9uIGZDKGEs
-Yil7dGhpcy5hPWEKdGhpcy5iPWJ9LApuVDpmdW5jdGlvbiBuVChhLGIsYyl7dGhpcy5hPWEKdGhpcy5i
-PWIKdGhpcy5jPWN9LApOWTpmdW5jdGlvbiBOWShhKXt0aGlzLmE9YX0sCnVlOmZ1bmN0aW9uIHVlKCl7
-fSwKZVg6ZnVuY3Rpb24gZVgoKXt9LApFRTpmdW5jdGlvbiBFRShhLGIsYyl7dGhpcy5hPWEKdGhpcy5i
-PWIKdGhpcy5jPWN9LApRTDpmdW5jdGlvbiBRTChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKVlM6ZnVu
-Y3Rpb24gVlMoYSl7dGhpcy5hPWF9LApURDpmdW5jdGlvbiBURChhLGIsYyl7dGhpcy5hPWEKdGhpcy5i
-PWIKdGhpcy5jPWN9LApJZjpmdW5jdGlvbiBJZihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5j
-PWN9LAp0QjpmdW5jdGlvbiB0Qigpe30sCm0yOmZ1bmN0aW9uIG0yKGEsYil7dGhpcy5hPWEKdGhpcy5i
-PWJ9LApYQTpmdW5jdGlvbiBYQSgpe30sClpzOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT1KLlU2KGEpCmlm
-KEwucDIoSC5oKHEucShhLCJ0eXBlIikpKT09PUMuWTIpe3M9SC5oKHEucShhLCJuYW1lIikpCnI9SC5o
-KHEucShhLCJwYXRoIikpCnE9cS5xKGEsInN1YnRyZWUiKQpxPW5ldyBMLnZ0KHE9PW51bGw/bnVsbDpM
-Lm1LKHEpLHMscikKcS5MVigpCnJldHVybiBxfWVsc2V7cz1ILmgocS5xKGEsIm5hbWUiKSkKcj1ILmgo
-cS5xKGEsInBhdGgiKSkKcmV0dXJuIG5ldyBMLmNEKEguaChxLnEoYSwiaHJlZiIpKSxILnVQKHEucShh
-LCJlZGl0Q291bnQiKSksSC55OChxLnEoYSwid2FzRXhwbGljaXRseU9wdGVkT3V0IikpLEwudkIoSC51
-UChxLnEoYSwibWlncmF0aW9uU3RhdHVzIikpKSxILnk4KHEucShhLCJtaWdyYXRpb25TdGF0dXNDYW5C
-ZUNoYW5nZWQiKSkscyxyKX19LAptSzpmdW5jdGlvbihhKXt2YXIgcyxyPUguVk0oW10sdC5jUSkKZm9y
-KHM9Si5JVCh0LlUuYShhKSk7cy5GKCk7KXIucHVzaChMLlpzKHMuZ2woKSkpCnJldHVybiByfSwKVkQ6
-ZnVuY3Rpb24oYSl7dmFyIHMscixxPUguVk0oW10sdC5HKQpmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxl
-bmd0aDthLmxlbmd0aD09PXN8fCgwLEgubGspKGEpLCsrcilxLnB1c2goYVtyXS5MdCgpKQpyZXR1cm4g
-cX0sCnZCOmZ1bmN0aW9uKGEpe2lmKGE9PW51bGwpcmV0dXJuIG51bGwKaWYoYT4+PjAhPT1hfHxhPj00
-KXJldHVybiBILk9IKEMubDAsYSkKcmV0dXJuIEMubDBbYV19LApwMjpmdW5jdGlvbihhKXtzd2l0Y2go
-YSl7Y2FzZSJkaXJlY3RvcnkiOnJldHVybiBDLlkyCmNhc2UiZmlsZSI6cmV0dXJuIEMucmYKZGVmYXVs
-dDp0aHJvdyBILmIoUC5QVigiVW5yZWNvZ25pemVkIG5hdmlnYXRpb24gdHJlZSBub2RlIHR5cGU6ICIr
-SC5FaihhKSkpfX0sCnZ0OmZ1bmN0aW9uIHZ0KGEsYixjKXt2YXIgXz10aGlzCl8uZD1hCl8uYT1iCl8u
-Yj1udWxsCl8uYz1jfSwKY0Q6ZnVuY3Rpb24gY0QoYSxiLGMsZCxlLGYsZyl7dmFyIF89dGhpcwpfLmQ9
-YQpfLmU9YgpfLmY9YwpfLnI9ZApfLng9ZQpfLmE9ZgpfLmI9bnVsbApfLmM9Z30sCkQ4OmZ1bmN0aW9u
-IEQ4KCl7fSwKTzk6ZnVuY3Rpb24gTzkoYSl7dGhpcy5iPWF9LApHYjpmdW5jdGlvbiBHYihhLGIpe3Ro
-aXMuYT1hCnRoaXMuYj1ifSwKSVY6ZnVuY3Rpb24gSVYoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmQ9YQpf
-LmU9YgpfLmY9YwpfLnI9ZH19LFg9ewpDTDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj1iLnha
-KGEpCmIuaEsoYSkKaWYobiE9bnVsbClhPUouS1YoYSxuLmxlbmd0aCkKcz10LnMKcj1ILlZNKFtdLHMp
-CnE9SC5WTShbXSxzKQpzPWEubGVuZ3RoCmlmKHMhPT0wJiZiLnI0KEMueEIuVyhhLDApKSl7aWYoMD49
-cylyZXR1cm4gSC5PSChhLDApCkMuTm0uaShxLGFbMF0pCnA9MX1lbHNle0MuTm0uaShxLCIiKQpwPTB9
-Zm9yKG89cDtvPHM7KytvKWlmKGIucjQoQy54Qi5XKGEsbykpKXtDLk5tLmkocixDLnhCLk5qKGEscCxv
-KSkKQy5ObS5pKHEsYVtvXSkKcD1vKzF9aWYocDxzKXtDLk5tLmkocixDLnhCLnluKGEscCkpCkMuTm0u
-aShxLCIiKX1yZXR1cm4gbmV3IFguV0QoYixuLHIscSl9LApXRDpmdW5jdGlvbiBXRChhLGIsYyxkKXt2
-YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uZD1jCl8uZT1kfSwKSTc6ZnVuY3Rpb24oYSl7cmV0dXJuIG5l
-dyBYLmR2KGEpfSwKZHY6ZnVuY3Rpb24gZHYoYSl7dGhpcy5hPWF9fSxPPXsKUmg6ZnVuY3Rpb24oKXt2
-YXIgcyxyPW51bGwKaWYoUC51bygpLmdGaSgpIT09ImZpbGUiKXJldHVybiAkLkViKCkKcz1QLnVvKCkK
-aWYoIUMueEIuVGMocy5nSWkocyksIi8iKSlyZXR1cm4gJC5FYigpCmlmKFAuS0wociwiYS9iIixyLHIs
-cixyLHIpLnQ0KCk9PT0iYVxcYiIpcmV0dXJuICQuS2soKQpyZXR1cm4gJC5iRCgpfSwKekw6ZnVuY3Rp
-b24gekwoKXt9fSxFPXtPRjpmdW5jdGlvbiBPRihhLGIsYyl7dGhpcy5kPWEKdGhpcy5lPWIKdGhpcy5m
-PWN9fSxGPXtydTpmdW5jdGlvbiBydShhLGIsYyxkKXt2YXIgXz10aGlzCl8uZD1hCl8uZT1iCl8uZj1j
-Cl8ucj1kfX0sRD17CmFiOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz1udWxsCnRyeXtvPVAudW8oKX1j
-YXRjaChzKXtpZih0Lmc4LmIoSC5SdShzKSkpe3I9JC5GZgppZihyIT1udWxsKXJldHVybiByCnRocm93
-IHN9ZWxzZSB0aHJvdyBzfWlmKEouUk0obywkLkk2KSl7cj0kLkZmCnIudG9TdHJpbmcKcmV0dXJuIHJ9
-JC5JNj1vCmlmKCQuSGsoKT09JC5FYigpKXI9JC5GZj1vLlpJKCIuIikudygwKQplbHNle3E9by50NCgp
-CnA9cS5sZW5ndGgtMQpyPSQuRmY9cD09PTA/cTpDLnhCLk5qKHEsMCxwKX1yLnRvU3RyaW5nCnJldHVy
-biByfX0KdmFyIHc9W0MsSCxKLFAsVyxNLFUsQixULEwsWCxPLEUsRixEXQpodW5rSGVscGVycy5zZXRG
-dW5jdGlvbk5hbWVzSWZOZWNlc3NhcnkodykKdmFyICQ9e30KSC5GSy5wcm90b3R5cGU9e30KSi5Hdi5w
-cm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe3JldHVybiBhPT09Yn0sCmdpTzpmdW5jdGlvbihhKXty
-ZXR1cm4gSC5lUShhKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5N
-KGEpKSsiJyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKGEsYi5nV2Eo
-KSxiLmduZCgpLGIuZ1ZtKCkpKX19CkoueUUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4g
-U3RyaW5nKGEpfSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBhPzUxOTAxODoyMTgxNTl9LAokaWEyOjF9
-Ckoud2UucHJvdG90eXBlPXsKRE46ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbnVsbD09Yn0sCnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIm51bGwifSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiAwfSwKZTc6ZnVuY3Rpb24o
-YSxiKXtyZXR1cm4gdGhpcy5TaihhLHQuby5hKGIpKX0sCiRpYzg6MX0KSi5NRi5wcm90b3R5cGU9ewpn
-aU86ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9LAok
-aXZtOjF9CkouaUMucHJvdG90eXBlPXt9Ckoua2QucHJvdG90eXBlPXt9CkouYzUucHJvdG90eXBlPXsK
-dzpmdW5jdGlvbihhKXt2YXIgcz1hWyQudygpXQppZihzPT1udWxsKXJldHVybiB0aGlzLnQoYSkKcmV0
-dXJuIkphdmFTY3JpcHQgZnVuY3Rpb24gZm9yICIrSC5FaihKLmoocykpfSwKJGlFSDoxfQpKLmpkLnBy
-b3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILmpWKGEsSC50NihhKS5DKCJAPDE+
-IikuS3EoYikuQygialY8MSwyPiIpKX0sCmk6ZnVuY3Rpb24oYSxiKXtILnQ2KGEpLmMuYShiKQppZigh
-IWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJhZGQiKSkKYS5wdXNoKGIpfSwKVzQ6ZnVuY3Rpb24oYSxi
-KXt2YXIgcwppZighIWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJyZW1vdmVBdCIpKQpzPWEubGVuZ3Ro
-CmlmKGI+PXMpdGhyb3cgSC5iKFAuTzcoYixudWxsKSkKcmV0dXJuIGEuc3BsaWNlKGIsMSlbMF19LApV
-RzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscgpILnQ2KGEpLkMoImNYPDE+IikuYShjKQppZighIWEuZml4
-ZWQkbGVuZ3RoKUgudihQLkw0KCJpbnNlcnRBbGwiKSkKUC53QShiLDAsYS5sZW5ndGgsImluZGV4IikK
-aWYoIXQuZC5iKGMpKWM9Si5SWChjKQpzPUouSG0oYykKYS5sZW5ndGg9YS5sZW5ndGgrcwpyPWIrcwp0
-aGlzLllXKGEscixhLmxlbmd0aCxhLGIpCnRoaXMudmcoYSxiLHIsYyl9LApGVjpmdW5jdGlvbihhLGIp
-e3ZhciBzCkgudDYoYSkuQygiY1g8MT4iKS5hKGIpCmlmKCEhYS5maXhlZCRsZW5ndGgpSC52KFAuTDQo
-ImFkZEFsbCIpKQppZihBcnJheS5pc0FycmF5KGIpKXt0aGlzLktoKGEsYikKcmV0dXJufWZvcihzPUou
-SVQoYik7cy5GKCk7KWEucHVzaChzLmdsKCkpfSwKS2g6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCnQuYi5h
-KGIpCnM9Yi5sZW5ndGgKaWYocz09PTApcmV0dXJuCmlmKGE9PT1iKXRocm93IEguYihQLmE0KGEpKQpm
-b3Iocj0wO3I8czsrK3IpYS5wdXNoKGJbcl0pfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUgudDYo
-YSkKcmV0dXJuIG5ldyBILmxKKGEscy5LcShjKS5DKCIxKDIpIikuYShiKSxzLkMoIkA8MT4iKS5LcShj
-KS5DKCJsSjwxLDI+IikpfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHI9UC5POChhLmxlbmd0aCwiIiwh
-MSx0Lk4pCmZvcihzPTA7czxhLmxlbmd0aDsrK3MpdGhpcy5ZNShyLHMsSC5FaihhW3NdKSkKcmV0dXJu
-IHIuam9pbihiKX0sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEgucUMoYSxiLG51bGwsSC50NihhKS5j
-KX0sCk4wOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQpkLmEoYikKSC50NihhKS5LcShkKS5DKCIx
-KDEsMikiKS5hKGMpCnM9YS5sZW5ndGgKZm9yKHI9YixxPTA7cTxzOysrcSl7cj1jLiQyKHIsYVtxXSkK
-aWYoYS5sZW5ndGghPT1zKXRocm93IEguYihQLmE0KGEpKX1yZXR1cm4gcn0sCkh0OmZ1bmN0aW9uKGEs
-Yil7dmFyIHMscixxLHAsbwpILnQ2KGEpLkMoImEyKDEpIikuYShiKQpzPWEubGVuZ3RoCmZvcihyPW51
-bGwscT0hMSxwPTA7cDxzOysrcCl7bz1hW3BdCmlmKEgub1QoYi4kMShvKSkpe2lmKHEpdGhyb3cgSC5i
-KEguQW0oKSkKcj1vCnE9ITB9aWYocyE9PWEubGVuZ3RoKXRocm93IEguYihQLmE0KGEpKX1pZihxKXJl
-dHVybiByCnRocm93IEguYihILldwKCkpfSwKRTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5n
-dGgpcmV0dXJuIEguT0goYSxiKQpyZXR1cm4gYVtiXX0sCmd0SDpmdW5jdGlvbihhKXtpZihhLmxlbmd0
-aD4wKXJldHVybiBhWzBdCnRocm93IEguYihILldwKCkpfSwKZ3JaOmZ1bmN0aW9uKGEpe3ZhciBzPWEu
-bGVuZ3RoCmlmKHM+MClyZXR1cm4gYVtzLTFdCnRocm93IEguYihILldwKCkpfSwKWVc6ZnVuY3Rpb24o
-YSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvCkgudDYoYSkuQygiY1g8MT4iKS5hKGQpCmlmKCEhYS5pbW11
-dGFibGUkbGlzdClILnYoUC5MNCgic2V0UmFuZ2UiKSkKUC5qQihiLGMsYS5sZW5ndGgpCnM9Yy1iCmlm
-KHM9PT0wKXJldHVybgpQLmsxKGUsInNraXBDb3VudCIpCmlmKHQuai5iKGQpKXtyPWQKcT1lfWVsc2V7
-cj1KLkE1KGQsZSkudHQoMCwhMSkKcT0wfXA9Si5VNihyKQppZihxK3M+cC5nQShyKSl0aHJvdyBILmIo
-SC5hcigpKQppZihxPGIpZm9yKG89cy0xO28+PTA7LS1vKWFbYitvXT1wLnEocixxK28pCmVsc2UgZm9y
-KG89MDtvPHM7KytvKWFbYitvXT1wLnEocixxK28pfSwKdmc6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJu
-IHRoaXMuWVcoYSxiLGMsZCwwKX0sClZyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILnQ2KGEpLkMoImEy
-KDEpIikuYShiKQpzPWEubGVuZ3RoCmZvcihyPTA7cjxzOysrcil7aWYoSC5vVChiLiQxKGFbcl0pKSly
-ZXR1cm4hMAppZihhLmxlbmd0aCE9PXMpdGhyb3cgSC5iKFAuYTQoYSkpfXJldHVybiExfSwKdGc6ZnVu
-Y3Rpb24oYSxiKXt2YXIgcwpmb3Iocz0wO3M8YS5sZW5ndGg7KytzKWlmKEouUk0oYVtzXSxiKSlyZXR1
-cm4hMApyZXR1cm4hMX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGg9PT0wfSwKZ29yOmZ1
-bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aCE9PTB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLldFKGEs
-IlsiLCJdIil9LAp0dDpmdW5jdGlvbihhLGIpe3ZhciBzPUguVk0oYS5zbGljZSgwKSxILnQ2KGEpKQpy
-ZXR1cm4gc30sCmJyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnR0KGEsITApfSwKZ206ZnVuY3Rpb24o
-YSl7cmV0dXJuIG5ldyBKLm0xKGEsYS5sZW5ndGgsSC50NihhKS5DKCJtMTwxPiIpKX0sCmdpTzpmdW5j
-dGlvbihhKXtyZXR1cm4gSC5lUShhKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCnNB
-OmZ1bmN0aW9uKGEsYil7aWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgic2V0IGxlbmd0aCIpKQpp
-ZihiPDApdGhyb3cgSC5iKFAuVEUoYiwwLG51bGwsIm5ld0xlbmd0aCIsbnVsbCkpCmEubGVuZ3RoPWJ9
-LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93IEguYihILkhZ
-KGEsYikpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe0gudDYoYSkuYy5hKGMpCmlmKCEh
-YS5pbW11dGFibGUkbGlzdClILnYoUC5MNCgiaW5kZXhlZCBzZXQiKSkKaWYoYj49YS5sZW5ndGh8fGI8
-MCl0aHJvdyBILmIoSC5IWShhLGIpKQphW2JdPWN9LAokaWJROjEsCiRpY1g6MSwKJGl6TToxfQpKLlBv
-LnByb3RvdHlwZT17fQpKLm0xLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0s
-CkY6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLmEscD1xLmxlbmd0aAppZihyLmIhPT1wKXRocm93
-IEguYihILmxrKHEpKQpzPXIuYwppZihzPj1wKXtyLnNNKG51bGwpCnJldHVybiExfXIuc00ocVtzXSk7
-KytyLmMKcmV0dXJuITB9LApzTTpmdW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEp
-fSwKJGlBbjoxfQpKLnFJLnByb3RvdHlwZT17CnpROmZ1bmN0aW9uKGEpe2lmKGE+MCl7aWYoYSE9PTEv
-MClyZXR1cm4gTWF0aC5yb3VuZChhKX1lbHNlIGlmKGE+LTEvMClyZXR1cm4gMC1NYXRoLnJvdW5kKDAt
-YSkKdGhyb3cgSC5iKFAuTDQoIiIrYSsiLnJvdW5kKCkiKSl9LAp3OmZ1bmN0aW9uKGEpe2lmKGE9PT0w
-JiYxL2E8MClyZXR1cm4iLTAuMCIKZWxzZSByZXR1cm4iIithfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBz
-LHIscSxwLG89YXwwCmlmKGE9PT1vKXJldHVybiBvJjUzNjg3MDkxMQpzPU1hdGguYWJzKGEpCnI9TWF0
-aC5sb2cocykvMC42OTMxNDcxODA1NTk5NDUzfDAKcT1NYXRoLnBvdygyLHIpCnA9czwxP3MvcTpxL3MK
-cmV0dXJuKChwKjkwMDcxOTkyNTQ3NDA5OTJ8MCkrKHAqMzU0MjI0MzE4MTE3NjUyMXwwKSkqNTk5MTk3
-K3IqMTI1OSY1MzY4NzA5MTF9LAp6WTpmdW5jdGlvbihhLGIpe3ZhciBzPWElYgppZihzPT09MClyZXR1
-cm4gMAppZihzPjApcmV0dXJuIHMKaWYoYjwwKXJldHVybiBzLWIKZWxzZSByZXR1cm4gcytifSwKQlU6
-ZnVuY3Rpb24oYSxiKXtyZXR1cm4oYXwwKT09PWE/YS9ifDA6dGhpcy5ESihhLGIpfSwKREo6ZnVuY3Rp
-b24oYSxiKXt2YXIgcz1hL2IKaWYocz49LTIxNDc0ODM2NDgmJnM8PTIxNDc0ODM2NDcpcmV0dXJuIHN8
-MAppZihzPjApe2lmKHMhPT0xLzApcmV0dXJuIE1hdGguZmxvb3Iocyl9ZWxzZSBpZihzPi0xLzApcmV0
-dXJuIE1hdGguY2VpbChzKQp0aHJvdyBILmIoUC5MNCgiUmVzdWx0IG9mIHRydW5jYXRpbmcgZGl2aXNp
-b24gaXMgIitILkVqKHMpKyI6ICIrSC5FaihhKSsiIH4vICIrYikpfSwKd0c6ZnVuY3Rpb24oYSxiKXt2
-YXIgcwppZihhPjApcz10aGlzLnAzKGEsYikKZWxzZXtzPWI+MzE/MzE6YgpzPWE+PnM+Pj4wfXJldHVy
-biBzfSwKYmY6ZnVuY3Rpb24oYSxiKXtpZihiPDApdGhyb3cgSC5iKEgudEwoYikpCnJldHVybiB0aGlz
-LnAzKGEsYil9LApwMzpmdW5jdGlvbihhLGIpe3JldHVybiBiPjMxPzA6YT4+PmJ9LAokaUNQOjEsCiRp
-Wlo6MX0KSi5iVS5wcm90b3R5cGU9eyRpQjI6MX0KSi5WQS5wcm90b3R5cGU9e30KSi5Eci5wcm90b3R5
-cGU9ewpPOmZ1bmN0aW9uKGEsYil7aWYoYjwwKXRocm93IEguYihILkhZKGEsYikpCmlmKGI+PWEubGVu
-Z3RoKUgudihILkhZKGEsYikpCnJldHVybiBhLmNoYXJDb2RlQXQoYil9LApXOmZ1bmN0aW9uKGEsYil7
-aWYoYj49YS5sZW5ndGgpdGhyb3cgSC5iKEguSFkoYSxiKSkKcmV0dXJuIGEuY2hhckNvZGVBdChiKX0s
-CmRkOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILnVuKGIsYSwwKX0sCmg6ZnVuY3Rpb24oYSxiKXtp
-Zih0eXBlb2YgYiE9InN0cmluZyIpdGhyb3cgSC5iKFAuTDMoYixudWxsLG51bGwpKQpyZXR1cm4gYSti
-fSwKVGM6ZnVuY3Rpb24oYSxiKXt2YXIgcz1iLmxlbmd0aCxyPWEubGVuZ3RoCmlmKHM+cilyZXR1cm4h
-MQpyZXR1cm4gYj09PXRoaXMueW4oYSxyLXMpfSwKaTc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9UC5q
-QihiLGMsYS5sZW5ndGgpLHI9YS5zdWJzdHJpbmcoMCxiKSxxPWEuc3Vic3RyaW5nKHMpCnJldHVybiBy
-K2QrcX0sClFpOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5i
-KFAuVEUoYywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YytiLmxlbmd0aAppZihzPmEubGVuZ3RoKXJl
-dHVybiExCnJldHVybiBiPT09YS5zdWJzdHJpbmcoYyxzKX0sCm46ZnVuY3Rpb24oYSxiKXtyZXR1cm4g
-dGhpcy5RaShhLGIsMCl9LApOajpmdW5jdGlvbihhLGIsYyl7aWYoYz09bnVsbCljPWEubGVuZ3RoCmlm
-KGI8MCl0aHJvdyBILmIoUC5PNyhiLG51bGwpKQppZihiPmMpdGhyb3cgSC5iKFAuTzcoYixudWxsKSkK
-aWYoYz5hLmxlbmd0aCl0aHJvdyBILmIoUC5PNyhjLG51bGwpKQpyZXR1cm4gYS5zdWJzdHJpbmcoYixj
-KX0sCnluOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuTmooYSxiLG51bGwpfSwKaGM6ZnVuY3Rpb24o
-YSl7cmV0dXJuIGEudG9Mb3dlckNhc2UoKX0sCmJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEudHJp
-bSgpLG89cC5sZW5ndGgKaWYobz09PTApcmV0dXJuIHAKaWYodGhpcy5XKHAsMCk9PT0xMzMpe3M9Si5t
-bShwLDEpCmlmKHM9PT1vKXJldHVybiIifWVsc2Ugcz0wCnI9by0xCnE9dGhpcy5PKHAscik9PT0xMzM/
-Si5jMShwLHIpOm8KaWYocz09PTAmJnE9PT1vKXJldHVybiBwCnJldHVybiBwLnN1YnN0cmluZyhzLHEp
-fSwKVDpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoMD49YilyZXR1cm4iIgppZihiPT09MXx8YS5sZW5n
-dGg9PT0wKXJldHVybiBhCmlmKGIhPT1iPj4+MCl0aHJvdyBILmIoQy5FcSkKZm9yKHM9YSxyPSIiOyEw
-Oyl7aWYoKGImMSk9PT0xKXI9cytyCmI9Yj4+PjEKaWYoYj09PTApYnJlYWsKcys9c31yZXR1cm4gcn0s
-ClhVOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5iKFAuVEUo
-YywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YS5pbmRleE9mKGIsYykKcmV0dXJuIHN9LApPWTpmdW5j
-dGlvbihhLGIpe3JldHVybiB0aGlzLlhVKGEsYiwwKX0sClBrOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxy
-CmlmKGM9PW51bGwpYz1hLmxlbmd0aAplbHNlIGlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5U
-RShjLDAsYS5sZW5ndGgsbnVsbCxudWxsKSkKcz1iLmxlbmd0aApyPWEubGVuZ3RoCmlmKGMrcz5yKWM9
-ci1zCnJldHVybiBhLmxhc3RJbmRleE9mKGIsYyl9LApjbjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlz
-LlBrKGEsYixudWxsKX0sCklzOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1hLmxlbmd0aAppZihjPnMpdGhy
-b3cgSC5iKFAuVEUoYywwLHMsbnVsbCxudWxsKSkKcmV0dXJuIEguU1EoYSxiLGMpfSwKdGc6ZnVuY3Rp
-b24oYSxiKXtyZXR1cm4gdGhpcy5JcyhhLGIsMCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBhfSwKZ2lP
-OmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1hLmxlbmd0aCxyPTAscT0wO3E8czsrK3Epe3I9cith
-LmNoYXJDb2RlQXQocSkmNTM2ODcwOTExCnI9cisoKHImNTI0Mjg3KTw8MTApJjUzNjg3MDkxMQpyXj1y
-Pj42fXI9cisoKHImNjcxMDg4NjMpPDwzKSY1MzY4NzA5MTEKcl49cj4+MTEKcmV0dXJuIHIrKChyJjE2
-MzgzKTw8MTUpJjUzNjg3MDkxMX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCnE6ZnVu
-Y3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+PWEubGVuZ3RofHwhMSl0aHJvdyBILmIoSC5IWShhLGIpKQpy
-ZXR1cm4gYVtiXX0sCiRpdlg6MSwKJGlxVToxfQpILkJSLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEp
-e3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILkU3KEouSVQodGhpcy5nT04oKSkscy5DKCJAPDE+
-IikuS3Eocy5RWzFdKS5DKCJFNzwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhp
-cy5nT04oKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudVUodGhpcy5nT04oKSl9LApnb3I6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIEouRjcodGhpcy5nT04oKSl9LAplUjpmdW5jdGlvbihhLGIpe3ZhciBzPUgu
-TGgodGhpcykKcmV0dXJuIEguR0ooSi5BNSh0aGlzLmdPTigpLGIpLHMuYyxzLlFbMV0pfSwKRTpmdW5j
-dGlvbihhLGIpe3JldHVybiBILkxoKHRoaXMpLlFbMV0uYShKLkdBKHRoaXMuZ09OKCksYikpfSwKdzpm
-dW5jdGlvbihhKXtyZXR1cm4gSi5qKHRoaXMuZ09OKCkpfX0KSC5FNy5wcm90b3R5cGU9ewpGOmZ1bmN0
-aW9uKCl7cmV0dXJuIHRoaXMuYS5GKCl9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLiR0aS5RWzFd
-LmEodGhpcy5hLmdsKCkpfSwKJGlBbjoxfQpILlp5LnByb3RvdHlwZT17CmdPTjpmdW5jdGlvbigpe3Jl
-dHVybiB0aGlzLmF9fQpILm9sLnByb3RvdHlwZT17JGliUToxfQpILlVxLnByb3RvdHlwZT17CnE6ZnVu
-Y3Rpb24oYSxiKXtyZXR1cm4gdGhpcy4kdGkuUVsxXS5hKEoueDkodGhpcy5hLEgudVAoYikpKX0sClk1
-OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz10aGlzLiR0aQpKLnU5KHRoaXMuYSxiLHMuYy5hKHMuUVsxXS5h
-KGMpKSl9LAokaWJROjEsCiRpek06MX0KSC5qVi5wcm90b3R5cGU9ewpkcjpmdW5jdGlvbihhLGIpe3Jl
-dHVybiBuZXcgSC5qVih0aGlzLmEsdGhpcy4kdGkuQygiQDwxPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9
-LApnT046ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hfX0KSC5uLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
-YSl7dmFyIHM9dGhpcy5hCnJldHVybiBzIT1udWxsPyJMYXRlSW5pdGlhbGl6YXRpb25FcnJvcjogIitz
-OiJMYXRlSW5pdGlhbGl6YXRpb25FcnJvciJ9fQpILnIzLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7
-dmFyIHM9IlJlYWNoYWJpbGl0eUVycm9yOiAiK3RoaXMuYQpyZXR1cm4gc319CkgucWoucHJvdG90eXBl
-PXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7cmV0
-dXJuIEMueEIuTyh0aGlzLmEsSC51UChiKSl9fQpILkdNLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7
-cmV0dXJuIk51bGwgaXMgbm90IGEgdmFsaWQgdmFsdWUgZm9yIHRoZSBwYXJhbWV0ZXIgJyIrdGhpcy5h
-KyInIG9mIHR5cGUgJyIrSC5LeCh0aGlzLiR0aS5jKS53KDApKyInIn19CkguYlEucHJvdG90eXBlPXt9
-CkguYUwucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpyZXR1cm4gbmV3IEguYTco
-cyxzLmdBKHMpLEguTGgocykuQygiYTc8YUwuRT4iKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
-aXMuZ0EodGhpcyk9PT0wfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPXRoaXMsbz1wLmdBKHAp
-CmlmKGIubGVuZ3RoIT09MCl7aWYobz09PTApcmV0dXJuIiIKcz1ILkVqKHAuRSgwLDApKQppZihvIT09
-cC5nQShwKSl0aHJvdyBILmIoUC5hNChwKSkKZm9yKHI9cyxxPTE7cTxvOysrcSl7cj1yK2IrSC5Faihw
-LkUoMCxxKSkKaWYobyE9PXAuZ0EocCkpdGhyb3cgSC5iKFAuYTQocCkpfXJldHVybiByLmNoYXJDb2Rl
-QXQoMCk9PTA/cjpyfWVsc2V7Zm9yKHE9MCxyPSIiO3E8bzsrK3Epe3IrPUguRWoocC5FKDAscSkpCmlm
-KG8hPT1wLmdBKHApKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6
-cn19LApldjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLkdHKDAsSC5MaCh0aGlzKS5DKCJhMihhTC5F
-KSIpLmEoYikpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBI
-LmxKKHRoaXMscy5LcShjKS5DKCIxKGFMLkUpIikuYShiKSxzLkMoIkA8YUwuRT4iKS5LcShjKS5DKCJs
-SjwxLDI+IikpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5xQyh0aGlzLGIsbnVsbCxILkxoKHRo
-aXMpLkMoImFMLkUiKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVybiBQLlkxKHRoaXMsITAsSC5MaCh0
-aGlzKS5DKCJhTC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9fQpILm5I
-LnByb3RvdHlwZT17CkhkOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9dGhpcy5iClAuazEociwic3Rh
-cnQiKQpzPXRoaXMuYwppZihzIT1udWxsKXtQLmsxKHMsImVuZCIpCmlmKHI+cyl0aHJvdyBILmIoUC5U
-RShyLDAscywic3RhcnQiLG51bGwpKX19LApnVUQ6ZnVuY3Rpb24oKXt2YXIgcz1KLkhtKHRoaXMuYSks
-cj10aGlzLmMKaWYocj09bnVsbHx8cj5zKXJldHVybiBzCnJldHVybiByfSwKZ0FzOmZ1bmN0aW9uKCl7
-dmFyIHM9Si5IbSh0aGlzLmEpLHI9dGhpcy5iCmlmKHI+cylyZXR1cm4gcwpyZXR1cm4gcn0sCmdBOmZ1
-bmN0aW9uKGEpe3ZhciBzLHI9Si5IbSh0aGlzLmEpLHE9dGhpcy5iCmlmKHE+PXIpcmV0dXJuIDAKcz10
-aGlzLmMKaWYocz09bnVsbHx8cz49cilyZXR1cm4gci1xCmlmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0
-dXJuIHMuSE4oKQpyZXR1cm4gcy1xfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMscj1zLmdBcygp
-K2IKaWYoYjwwfHxyPj1zLmdVRCgpKXRocm93IEguYihQLkNmKGIscywiaW5kZXgiLG51bGwsbnVsbCkp
-CnJldHVybiBKLkdBKHMuYSxyKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKUC5rMShi
-LCJjb3VudCIpCnM9cS5iK2IKcj1xLmMKaWYociE9bnVsbCYmcz49cilyZXR1cm4gbmV3IEguTUIocS4k
-dGkuQygiTUI8MT4iKSkKcmV0dXJuIEgucUMocS5hLHMscixxLiR0aS5jKX0sCnR0OmZ1bmN0aW9uKGEs
-Yil7dmFyIHMscixxLHA9dGhpcyxvPXAuYixuPXAuYSxtPUouVTYobiksbD1tLmdBKG4pLGs9cC5jCmlm
-KGshPW51bGwmJms8bClsPWsKaWYodHlwZW9mIGwhPT0ibnVtYmVyIilyZXR1cm4gbC5ITigpCnM9bC1v
-CmlmKHM8PTApe249Si5RaSgwLHAuJHRpLmMpCnJldHVybiBufXI9UC5POChzLG0uRShuLG8pLCExLHAu
-JHRpLmMpCmZvcihxPTE7cTxzOysrcSl7Qy5ObS5ZNShyLHEsbS5FKG4sbytxKSkKaWYobS5nQShuKTxs
-KXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gcn19CkguYTcucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24o
-KXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxwPUouVTYocSks
-bz1wLmdBKHEpCmlmKHIuYiE9PW8pdGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM+PW8pe3Iuc0ko
-bnVsbCkKcmV0dXJuITF9ci5zSShwLkUocSxzKSk7KytyLmMKcmV0dXJuITB9LApzSTpmdW5jdGlvbihh
-KXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpILmkxLnByb3RvdHlwZT17Cmdt
-OmZ1bmN0aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILk1IKEouSVQodGhpcy5hKSx0
-aGlzLmIscy5DKCJAPDE+IikuS3Eocy5RWzFdKS5DKCJNSDwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7
-cmV0dXJuIEouSG0odGhpcy5hKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmEpfSwK
-RTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmIuJDEoSi5HQSh0aGlzLmEsYikpfX0KSC54eS5wcm90
-b3R5cGU9eyRpYlE6MX0KSC5NSC5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMu
-YgppZihyLkYoKSl7cy5zSShzLmMuJDEoci5nbCgpKSkKcmV0dXJuITB9cy5zSShudWxsKQpyZXR1cm4h
-MX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX0sCnNJOmZ1bmN0aW9uKGEpe3RoaXMuYT10aGlz
-LiR0aS5DKCIyPyIpLmEoYSl9fQpILmxKLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBK
-LkhtKHRoaXMuYSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYi4kMShKLkdBKHRoaXMuYSxi
-KSl9fQpILlU1LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5TTyhKLklUKHRo
-aXMuYSksdGhpcy5iLHRoaXMuJHRpLkMoIlNPPDE+IikpfX0KSC5TTy5wcm90b3R5cGU9ewpGOmZ1bmN0
-aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLmI7cy5GKCk7KWlmKEgub1Qoci4kMShzLmds
-KCkpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5nbCgpfX0K
-SC5BTS5wcm90b3R5cGU9ewplUjpmdW5jdGlvbihhLGIpe1AuTVIoYiwiY291bnQiLHQuUykKUC5rMShi
-LCJjb3VudCIpCnJldHVybiBuZXcgSC5BTSh0aGlzLmEsdGhpcy5iK2IsSC5MaCh0aGlzKS5DKCJBTTwx
-PiIpKX0sCmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5VMShKLklUKHRoaXMuYSksdGhpcy5iLEgu
-TGgodGhpcykuQygiVTE8MT4iKSl9fQpILmQ1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3ZhciBz
-PUouSG0odGhpcy5hKS10aGlzLmIKaWYocz49MClyZXR1cm4gcwpyZXR1cm4gMH0sCmVSOmZ1bmN0aW9u
-KGEsYil7UC5NUihiLCJjb3VudCIsdC5TKQpQLmsxKGIsImNvdW50IikKcmV0dXJuIG5ldyBILmQ1KHRo
-aXMuYSx0aGlzLmIrYix0aGlzLiR0aSl9LAokaWJROjF9CkguVTEucHJvdG90eXBlPXsKRjpmdW5jdGlv
-bigpe3ZhciBzLHIKZm9yKHM9dGhpcy5hLHI9MDtyPHRoaXMuYjsrK3Ipcy5GKCkKdGhpcy5iPTAKcmV0
-dXJuIHMuRigpfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmdsKCl9fQpILk1CLnByb3RvdHlw
-ZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBDLkd3fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiEwfSwK
-Z0E6ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LApFOmZ1bmN0aW9uKGEsYil7dGhyb3cgSC5iKFAuVEUoYiww
-LDAsImluZGV4IixudWxsKSl9LAplUjpmdW5jdGlvbihhLGIpe1AuazEoYiwiY291bnQiKQpyZXR1cm4g
-dGhpc319CkguRnUucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3JldHVybiExfSwKZ2w6ZnVuY3Rpb24o
-KXt0aHJvdyBILmIoSC5XcCgpKX0sCiRpQW46MX0KSC51Ni5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihh
-KXtyZXR1cm4gbmV3IEguSkIoSi5JVCh0aGlzLmEpLHRoaXMuJHRpLkMoIkpCPDE+IikpfX0KSC5KQi5w
-cm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLiR0aS5jO3Mu
-RigpOylpZihyLmIocy5nbCgpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJu
-IHRoaXMuJHRpLmMuYSh0aGlzLmEuZ2woKSl9LAokaUFuOjF9CkguU1UucHJvdG90eXBlPXt9CkguUmUu
-cHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe0guTGgodGhpcykuQygiUmUuRSIpLmEoYykKdGhy
-b3cgSC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgYW4gdW5tb2RpZmlhYmxlIGxpc3QiKSl9fQpILncyLnBy
-b3RvdHlwZT17fQpILnd2LnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLl9oYXNo
-Q29kZQppZihzIT1udWxsKXJldHVybiBzCnM9NjY0NTk3KkouaGYodGhpcy5hKSY1MzY4NzA5MTEKdGhp
-cy5faGFzaENvZGU9cwpyZXR1cm4gc30sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuJ1N5bWJvbCgiJytILkVq
-KHRoaXMuYSkrJyIpJ30sCkROOmZ1bmN0aW9uKGEsYil7aWYoYj09bnVsbClyZXR1cm4hMQpyZXR1cm4g
-YiBpbnN0YW5jZW9mIEgud3YmJnRoaXMuYT09Yi5hfSwKJGlHRDoxfQpILlFDLnByb3RvdHlwZT17fQpI
-LlBELnByb3RvdHlwZT17fQpILldVLnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
-cy5nQSh0aGlzKT09PTB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLm5PKHRoaXMpfSwKWTU6ZnVuY3Rp
-b24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcy5jLmEoYikKcy5RWzFdLmEoYykKSC5kYygpCkguQmko
-dS5nKX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5xNChhLEguTGgodGhpcykuQygiTjM8MSwy
-PiIpKX0sCnE0OmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcwpyZXR1cm4gUC5sMChmdW5jdGlvbigpe3Zh
-ciByPWEKdmFyIHE9MCxwPTEsbyxuLG0sbCxrCnJldHVybiBmdW5jdGlvbiAkYXN5bmMkZ1B1KGMsZCl7
-aWYoYz09PTEpe289ZApxPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocSl7Y2FzZSAwOm49cy5ndmMoKSxuPW4u
-Z20obiksbT1ILkxoKHMpLG09bS5DKCJAPDE+IikuS3EobS5RWzFdKS5DKCJOMzwxLDI+IikKY2FzZSAy
-OmlmKCFuLkYoKSl7cT0zCmJyZWFrfWw9bi5nbCgpCms9cy5xKDAsbCkKay50b1N0cmluZwpxPTQKcmV0
-dXJuIG5ldyBQLk4zKGwsayxtKQpjYXNlIDQ6cT0yCmJyZWFrCmNhc2UgMzpyZXR1cm4gUC5UaCgpCmNh
-c2UgMTpyZXR1cm4gUC5ZbShvKX19fSxiKX0sCiRpWjA6MX0KSC5MUC5wcm90b3R5cGU9ewpnQTpmdW5j
-dGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGEhPSJzdHJpbmci
-KXJldHVybiExCmlmKCJfX3Byb3RvX18iPT09YSlyZXR1cm4hMQpyZXR1cm4gdGhpcy5iLmhhc093blBy
-b3BlcnR5KGEpfSwKcTpmdW5jdGlvbihhLGIpe2lmKCF0aGlzLng0KGIpKXJldHVybiBudWxsCnJldHVy
-biB0aGlzLnFQKGIpfSwKcVA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYltILmgoYSldfSwKSzpmdW5j
-dGlvbihhLGIpe3ZhciBzLHIscSxwLG89SC5MaCh0aGlzKQpvLkMoIn4oMSwyKSIpLmEoYikKcz10aGlz
-LmMKZm9yKHI9cy5sZW5ndGgsbz1vLlFbMV0scT0wO3E8cjsrK3Epe3A9c1txXQpiLiQyKHAsby5hKHRo
-aXMucVAocCkpKX19LApndmM6ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEguWFIodGhpcyxILkxoKHRoaXMp
-LkMoIlhSPDE+IikpfX0KSC5YUi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEu
-YwpyZXR1cm4gbmV3IEoubTEocyxzLmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfSwKZ0E6ZnVuY3Rp
-b24oYSl7cmV0dXJuIHRoaXMuYS5jLmxlbmd0aH19CkguTEkucHJvdG90eXBlPXsKZ1dhOmZ1bmN0aW9u
-KCl7dmFyIHM9dGhpcy5hCnJldHVybiBzfSwKZ25kOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlz
-CmlmKG8uYz09PTEpcmV0dXJuIEMuaFUKcz1vLmQKcj1zLmxlbmd0aC1vLmUubGVuZ3RoLW8uZgppZihy
-PT09MClyZXR1cm4gQy5oVQpxPVtdCmZvcihwPTA7cDxyOysrcCl7aWYocD49cy5sZW5ndGgpcmV0dXJu
-IEguT0gocyxwKQpxLnB1c2goc1twXSl9cmV0dXJuIEouekMocSl9LApnVm06ZnVuY3Rpb24oKXt2YXIg
-cyxyLHEscCxvLG4sbSxsLGs9dGhpcwppZihrLmMhPT0wKXJldHVybiBDLldPCnM9ay5lCnI9cy5sZW5n
-dGgKcT1rLmQKcD1xLmxlbmd0aC1yLWsuZgppZihyPT09MClyZXR1cm4gQy5XTwpvPW5ldyBILk41KHQu
-ZW8pCmZvcihuPTA7bjxyOysrbil7aWYobj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxuKQptPXNbbl0K
-bD1wK24KaWYobDwwfHxsPj1xLmxlbmd0aClyZXR1cm4gSC5PSChxLGwpCm8uWTUoMCxuZXcgSC53diht
-KSxxW2xdKX1yZXR1cm4gbmV3IEguUEQobyx0LmdGKX0sCiRpdlE6MX0KSC5Dai5wcm90b3R5cGU9ewok
-MjpmdW5jdGlvbihhLGIpe3ZhciBzCkguaChhKQpzPXRoaXMuYQpzLmI9cy5iKyIkIitILkVqKGEpCkMu
-Tm0uaSh0aGlzLmIsYSkKQy5ObS5pKHRoaXMuYyxiKTsrK3MuYX0sCiRTOjEzfQpILmY5LnByb3RvdHlw
-ZT17CnFTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9bmV3IFJlZ0V4cChxLmEpLmV4ZWMoYSkK
-aWYocD09bnVsbClyZXR1cm4gbnVsbApzPU9iamVjdC5jcmVhdGUobnVsbCkKcj1xLmIKaWYociE9PS0x
-KXMuYXJndW1lbnRzPXBbcisxXQpyPXEuYwppZihyIT09LTEpcy5hcmd1bWVudHNFeHByPXBbcisxXQpy
-PXEuZAppZihyIT09LTEpcy5leHByPXBbcisxXQpyPXEuZQppZihyIT09LTEpcy5tZXRob2Q9cFtyKzFd
-CnI9cS5mCmlmKHIhPT0tMSlzLnJlY2VpdmVyPXBbcisxXQpyZXR1cm4gc319CkguVzAucHJvdG90eXBl
-PXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIKaWYocz09bnVsbClyZXR1cm4iTm9TdWNoTWV0aG9k
-RXJyb3I6ICIrSC5Faih0aGlzLmEpCnJldHVybiJOb1N1Y2hNZXRob2RFcnJvcjogbWV0aG9kIG5vdCBm
-b3VuZDogJyIrcysiJyBvbiBudWxsIn19CkguYXoucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIg
-cyxyPXRoaXMscT0iTm9TdWNoTWV0aG9kRXJyb3I6IG1ldGhvZCBub3QgZm91bmQ6ICciLHA9ci5iCmlm
-KHA9PW51bGwpcmV0dXJuIk5vU3VjaE1ldGhvZEVycm9yOiAiK0guRWooci5hKQpzPXIuYwppZihzPT1u
-dWxsKXJldHVybiBxK3ArIicgKCIrSC5FaihyLmEpKyIpIgpyZXR1cm4gcStwKyInIG9uICciK3MrIicg
-KCIrSC5FaihyLmEpKyIpIn19CkgudlYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlz
-LmEKcmV0dXJuIHMubGVuZ3RoPT09MD8iRXJyb3IiOiJFcnJvcjogIitzfX0KSC50ZS5wcm90b3R5cGU9
-ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJUaHJvdyBvZiBudWxsICgnIisodGhpcy5hPT09bnVsbD8ibnVs
-bCI6InVuZGVmaW5lZCIpKyInIGZyb20gSmF2YVNjcmlwdCkifSwKJGlSejoxfQpILmJxLnByb3RvdHlw
-ZT17fQpILlhPLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLmIKaWYociE9bnVs
-bClyZXR1cm4gcgpyPXRoaXMuYQpzPXIhPT1udWxsJiZ0eXBlb2Ygcj09PSJvYmplY3QiP3Iuc3RhY2s6
-bnVsbApyZXR1cm4gdGhpcy5iPXM9PW51bGw/IiI6c30sCiRpR3o6MX0KSC5UcC5wcm90b3R5cGU9ewp3
-OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuY29uc3RydWN0b3Iscj1zPT1udWxsP251bGw6cy5uYW1lCnJl
-dHVybiJDbG9zdXJlICciK0guTlEocj09bnVsbD8idW5rbm93biI6cikrIicifSwKJGlFSDoxLApnS3U6
-ZnVuY3Rpb24oKXtyZXR1cm4gdGhpc30sCiRDOiIkMSIsCiRSOjEsCiREOm51bGx9CkgubGMucHJvdG90
-eXBlPXt9CkguengucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiRzdGF0aWNfbmFt
-ZQppZihzPT1udWxsKXJldHVybiJDbG9zdXJlIG9mIHVua25vd24gc3RhdGljIG1ldGhvZCIKcmV0dXJu
-IkNsb3N1cmUgJyIrSC5OUShzKSsiJyJ9fQpILnJULnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7
-dmFyIHM9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHM9PT1iKXJldHVybiEwCmlmKCEoYiBpbnN0
-YW5jZW9mIEguclQpKXJldHVybiExCnJldHVybiBzLmE9PT1iLmEmJnMuYj09PWIuYiYmcy5jPT09Yi5j
-fSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5jCmlmKHI9PW51bGwpcz1ILmVRKHRoaXMuYSkK
-ZWxzZSBzPXR5cGVvZiByIT09Im9iamVjdCI/Si5oZihyKTpILmVRKHIpCnI9SC5lUSh0aGlzLmIpCmlm
-KHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIHMuWSgpCnJldHVybihzXnIpPj4+MH0sCnc6ZnVuY3Rp
-b24oYSl7dmFyIHM9dGhpcy5jCmlmKHM9PW51bGwpcz10aGlzLmEKcmV0dXJuIkNsb3N1cmUgJyIrSC5F
-aih0aGlzLmQpKyInIG9mICIrKCJJbnN0YW5jZSBvZiAnIitILkVqKEguTShzKSkrIiciKX19CkguRXEu
-cHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iUnVudGltZUVycm9yOiAiK3RoaXMuYX19Ckgu
-a1kucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDogIitQLnAo
-dGhpcy5hKX19Ckgua3IucHJvdG90eXBlPXt9CkguTjUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7
-cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09MH0sCmd2YzpmdW5j
-dGlvbigpe3JldHVybiBuZXcgSC5pNSh0aGlzLEguTGgodGhpcykuQygiaTU8MT4iKSl9LAp4NDpmdW5j
-dGlvbihhKXt2YXIgcyxyCmlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz10aGlzLmIKaWYocz09bnVsbCly
-ZXR1cm4hMQpyZXR1cm4gdGhpcy5YdShzLGEpfWVsc2V7cj10aGlzLkNYKGEpCnJldHVybiByfX0sCkNY
-OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZAppZihzPT1udWxsKXJldHVybiExCnJldHVybiB0aGlzLkZo
-KHRoaXMuQnQocyxKLmhmKGEpJjB4M2ZmZmZmZiksYSk+PTB9LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMs
-cixxLHAsbz10aGlzLG49bnVsbAppZih0eXBlb2YgYj09InN0cmluZyIpe3M9by5iCmlmKHM9PW51bGwp
-cmV0dXJuIG4Kcj1vLmoyKHMsYikKcT1yPT1udWxsP246ci5iCnJldHVybiBxfWVsc2UgaWYodHlwZW9m
-IGI9PSJudW1iZXIiJiYoYiYweDNmZmZmZmYpPT09Yil7cD1vLmMKaWYocD09bnVsbClyZXR1cm4gbgpy
-PW8uajIocCxiKQpxPXI9PW51bGw/bjpyLmIKcmV0dXJuIHF9ZWxzZSByZXR1cm4gby5hYShiKX0sCmFh
-OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLmQKaWYocT09bnVsbClyZXR1cm4gbnVsbApzPXRoaXMu
-QnQocSxKLmhmKGEpJjB4M2ZmZmZmZikKcj10aGlzLkZoKHMsYSkKaWYocjwwKXJldHVybiBudWxsCnJl
-dHVybiBzW3JdLmJ9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPUgu
-TGgobSkKbC5jLmEoYikKbC5RWzFdLmEoYykKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPW0uYgptLkVI
-KHM9PW51bGw/bS5iPW0ueksoKTpzLGIsYyl9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJlciImJihiJjB4
-M2ZmZmZmZik9PT1iKXtyPW0uYwptLkVIKHI9PW51bGw/bS5jPW0ueksoKTpyLGIsYyl9ZWxzZXtxPW0u
-ZAppZihxPT1udWxsKXE9bS5kPW0ueksoKQpwPUouaGYoYikmMHgzZmZmZmZmCm89bS5CdChxLHApCmlm
-KG89PW51bGwpbS5FSShxLHAsW20uSG4oYixjKV0pCmVsc2V7bj1tLkZoKG8sYikKaWYobj49MClvW25d
-LmI9YwplbHNlIG8ucHVzaChtLkhuKGIsYykpfX19LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRo
-aXMKSC5MaChxKS5DKCJ+KDEsMikiKS5hKGIpCnM9cS5lCnI9cS5yCmZvcig7cyE9bnVsbDspe2IuJDIo
-cy5hLHMuYikKaWYociE9PXEucil0aHJvdyBILmIoUC5hNChxKSkKcz1zLmN9fSwKRUg6ZnVuY3Rpb24o
-YSxiLGMpe3ZhciBzLHI9dGhpcyxxPUguTGgocikKcS5jLmEoYikKcS5RWzFdLmEoYykKcz1yLmoyKGEs
-YikKaWYocz09bnVsbClyLkVJKGEsYixyLkhuKGIsYykpCmVsc2Ugcy5iPWN9LAprczpmdW5jdGlvbigp
-e3RoaXMucj10aGlzLnIrMSY2NzEwODg2M30sCkhuOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcyxyPUgu
-TGgocykscT1uZXcgSC52aChyLmMuYShhKSxyLlFbMV0uYShiKSkKaWYocy5lPT1udWxsKXMuZT1zLmY9
-cQplbHNle3I9cy5mCnIudG9TdHJpbmcKcS5kPXIKcy5mPXIuYz1xfSsrcy5hCnMua3MoKQpyZXR1cm4g
-cX0sCkZoOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZihhPT1udWxsKXJldHVybi0xCnM9YS5sZW5ndGgK
-Zm9yKHI9MDtyPHM7KytyKWlmKEouUk0oYVtyXS5hLGIpKXJldHVybiByCnJldHVybi0xfSwKdzpmdW5j
-dGlvbihhKXtyZXR1cm4gUC5uTyh0aGlzKX0sCmoyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGFbYl19LApC
-dDpmdW5jdGlvbihhLGIpe3JldHVybiBhW2JdfSwKRUk6ZnVuY3Rpb24oYSxiLGMpe2FbYl09Y30sCnJu
-OmZ1bmN0aW9uKGEsYil7ZGVsZXRlIGFbYl19LApYdTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmoy
-KGEsYikhPW51bGx9LAp6SzpmdW5jdGlvbigpe3ZhciBzPSI8bm9uLWlkZW50aWZpZXIta2V5PiIscj1P
-YmplY3QuY3JlYXRlKG51bGwpCnRoaXMuRUkocixzLHIpCnRoaXMucm4ocixzKQpyZXR1cm4gcn0sCiRp
-Rm86MX0KSC52aC5wcm90b3R5cGU9e30KSC5pNS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1
-cm4gdGhpcy5hLmF9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5hPT09MH0sCmdtOmZ1bmN0
-aW9uKGEpe3ZhciBzPXRoaXMuYSxyPW5ldyBILk42KHMscy5yLHRoaXMuJHRpLkMoIk42PDE+IikpCnIu
-Yz1zLmUKcmV0dXJuIHJ9LAp0ZzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEueDQoYil9fQpILk42
-LnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rpb24oKXt2YXIg
-cyxyPXRoaXMscT1yLmEKaWYoci5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXIuYwppZihzPT1u
-dWxsKXtyLnNxWShudWxsKQpyZXR1cm4hMX1lbHNle3Iuc3FZKHMuYSkKci5jPXMuYwpyZXR1cm4hMH19
-LApzcVk6ZnVuY3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KSC5k
-Qy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hKGEpfSwKJFM6NH0KSC53Ti5w
-cm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEoYSxiKX0sCiRTOjQ2fQpILlZY
-LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEoSC5oKGEpKX0sCiRTOjQxfQpI
-LlZSLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlJlZ0V4cC8iK3RoaXMuYSsiLyIrdGhp
-cy5iLmZsYWdzfSwKZ0hjOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYwppZihyIT1udWxsKXJldHVy
-biByCnI9cy5iCnJldHVybiBzLmM9SC52NChzLmEsci5tdWx0aWxpbmUsIXIuaWdub3JlQ2FzZSxyLnVu
-aWNvZGUsci5kb3RBbGwsITApfSwKZGQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguS1codGhpcyxi
-LDApfSwKVVo6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuZ0hjKCkKci5sYXN0SW5kZXg9YgpzPXIu
-ZXhlYyhhKQppZihzPT1udWxsKXJldHVybiBudWxsCnJldHVybiBuZXcgSC5FSyhzKX0sCiRpdlg6MSwK
-JGl3TDoxfQpILkVLLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIpCnM9dGhp
-cy5iCmlmKGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHNbYl19LAokaU9kOjEsCiRp
-aWI6MX0KSC5LVy5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguUGIodGhpcy5h
-LHRoaXMuYix0aGlzLmMpfX0KSC5QYi5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVybiB0aGlz
-LmR9LApGOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPW0uYgppZihsPT1udWxsKXJl
-dHVybiExCnM9bS5jCnI9bC5sZW5ndGgKaWYoczw9cil7cT1tLmEKcD1xLlVaKGwscykKaWYocCE9bnVs
-bCl7bS5kPXAKcz1wLmIKbz1zLmluZGV4Cm49bytzWzBdLmxlbmd0aAppZihvPT09bil7aWYocS5iLnVu
-aWNvZGUpe3M9bS5jCnE9cysxCmlmKHE8cil7cz1DLnhCLk8obCxzKQppZihzPj01NTI5NiYmczw9NTYz
-MTkpe3M9Qy54Qi5PKGwscSkKcz1zPj01NjMyMCYmczw9NTczNDN9ZWxzZSBzPSExfWVsc2Ugcz0hMX1l
-bHNlIHM9ITEKbj0ocz9uKzE6bikrMX1tLmM9bgpyZXR1cm4hMH19bS5iPW0uZD1udWxsCnJldHVybiEx
-fSwKJGlBbjoxfQpILnRRLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGIhPT0w
-KUgudihQLk83KGIsbnVsbCkpCnJldHVybiB0aGlzLmN9LAokaU9kOjF9CkgudW4ucHJvdG90eXBlPXsK
-Z206ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBILlNkKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX19CkguU2Qu
-cHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzLHIscT10aGlzLHA9cS5jLG89cS5iLG49by5sZW5n
-dGgsbT1xLmEsbD1tLmxlbmd0aAppZihwK24+bCl7cS5kPW51bGwKcmV0dXJuITF9cz1tLmluZGV4T2Yo
-byxwKQppZihzPDApe3EuYz1sKzEKcS5kPW51bGwKcmV0dXJuITF9cj1zK24KcS5kPW5ldyBILnRRKHMs
-bykKcS5jPXI9PT1xLmM/cisxOnIKcmV0dXJuITB9LApnbDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuZApz
-LnRvU3RyaW5nCnJldHVybiBzfSwKJGlBbjoxfQpILkVULnByb3RvdHlwZT17JGlFVDoxLCRpQVM6MX0K
-SC5MWi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LAokaVhqOjF9Ckgu
-RGcucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJl
-dHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe0guR0goYykKSC5vZChiLGEsYS5sZW5ndGgpCmFb
-Yl09Y30sCiRpYlE6MSwKJGljWDoxLAokaXpNOjF9CkguUGcucHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24o
-YSxiLGMpe0gudVAoYykKSC5vZChiLGEsYS5sZW5ndGgpCmFbYl09Y30sCiRpYlE6MSwKJGljWDoxLAok
-aXpNOjF9CkgueGoucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5s
-ZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kRS5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChi
-KQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILlpBLnByb3RvdHlwZT17CnE6ZnVuY3Rp
-b24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVtiXX19CkguZFQucHJvdG90
-eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2Jd
-fX0KSC5QcS5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0
-aCkKcmV0dXJuIGFbYl19fQpILmVFLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxl
-bmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVti
-XX19CkguVjYucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5j
-dGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfSwKJGlWNjoxLAok
-aW42OjF9CkguUkcucHJvdG90eXBlPXt9CkguVlAucHJvdG90eXBlPXt9CkguV0IucHJvdG90eXBlPXt9
-CkguWkcucHJvdG90eXBlPXt9CkguSmMucHJvdG90eXBlPXsKQzpmdW5jdGlvbihhKXtyZXR1cm4gSC5j
-RSh2LnR5cGVVbml2ZXJzZSx0aGlzLGEpfSwKS3E6ZnVuY3Rpb24oYSl7cmV0dXJuIEgudjUodi50eXBl
-VW5pdmVyc2UsdGhpcyxhKX19CkguRy5wcm90b3R5cGU9e30KSC5sWS5wcm90b3R5cGU9ewp3OmZ1bmN0
-aW9uKGEpe3JldHVybiBILmRtKHRoaXMuYSxudWxsKX19Ckgua1MucHJvdG90eXBlPXsKdzpmdW5jdGlv
-bihhKXtyZXR1cm4gdGhpcy5hfX0KSC5pTS5wcm90b3R5cGU9e30KUC50aC5wcm90b3R5cGU9ewokMTpm
-dW5jdGlvbihhKXt2YXIgcz10aGlzLmEscj1zLmEKcy5hPW51bGwKci4kMCgpfSwKJFM6MTB9ClAuaGEu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscgp0aGlzLmEuYT10Lk0uYShhKQpzPXRoaXMu
-YgpyPXRoaXMuYwpzLmZpcnN0Q2hpbGQ/cy5yZW1vdmVDaGlsZChyKTpzLmFwcGVuZENoaWxkKHIpfSwK
-JFM6MzR9ClAuVnMucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuJDAoKX0sCiRDOiIkMCIs
-CiRSOjAsCiRTOjJ9ClAuRnQucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuJDAoKX0sCiRD
-OiIkMCIsCiRSOjAsCiRTOjJ9ClAuVzMucHJvdG90eXBlPXsKQ1k6ZnVuY3Rpb24oYSxiKXtpZihzZWxm
-LnNldFRpbWVvdXQhPW51bGwpc2VsZi5zZXRUaW1lb3V0KEgudFIobmV3IFAueUgodGhpcyxiKSwwKSxh
-KQplbHNlIHRocm93IEguYihQLkw0KCJgc2V0VGltZW91dCgpYCBub3QgZm91bmQuIikpfX0KUC55SC5w
-cm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYi4kMCgpfSwKJEM6IiQwIiwKJFI6MCwKJFM6MH0K
-UC5paC5wcm90b3R5cGU9ewphTTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcyxxPXIuJHRpCnEuQygi
-MS8/IikuYShiKQppZighci5iKXIuYS5YZihiKQplbHNle3M9ci5hCmlmKHEuQygiYjg8MT4iKS5iKGIp
-KXMuY1UoYikKZWxzZSBzLlgyKHEuYy5hKGIpKX19LAp3MDpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKGI9
-PW51bGwpYj1QLnYwKGEpCnM9dGhpcy5hCmlmKHRoaXMuYilzLlpMKGEsYikKZWxzZSBzLk5rKGEsYil9
-fQpQLldNLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuJDIoMCxhKX0sCiRT
-OjUyfQpQLlNYLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5hLiQyKDEsbmV3IEguYnEo
-YSx0LmwuYShiKSkpfSwKJEM6IiQyIiwKJFI6MiwKJFM6MjR9ClAuR3MucHJvdG90eXBlPXsKJDI6ZnVu
-Y3Rpb24oYSxiKXt0aGlzLmEoSC51UChhKSxiKX0sCiRTOjI2fQpQLkZ5LnByb3RvdHlwZT17Cnc6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIkl0ZXJhdGlvbk1hcmtlcigiK3RoaXMuYisiLCAiK0guRWoodGhpcy5hKSsi
-KSJ9fQpQLkdWLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5jCmlmKHM9PW51bGwp
-cmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLmIpCnJldHVybiBzLmdsKCl9LApGOmZ1bmN0aW9uKCl7dmFy
-IHMscixxLHAsbyxuLG09dGhpcwpmb3Iocz1tLiR0aS5DKCJBbjwxPiIpOyEwOyl7cj1tLmMKaWYociE9
-bnVsbClpZihyLkYoKSlyZXR1cm4hMAplbHNlIG0uc1g5KG51bGwpCnE9ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBsLGs9Ygp3aGlsZSh0cnVlKXRyeXtyZXR1cm4gYShrLGwpfWNhdGNoKGope2w9agprPWN9fShtLmEs
-MCwxKQppZihxIGluc3RhbmNlb2YgUC5GeSl7cD1xLmIKaWYocD09PTIpe289bS5kCmlmKG89PW51bGx8
-fG8ubGVuZ3RoPT09MCl7bS5zRUMobnVsbCkKcmV0dXJuITF9aWYoMD49by5sZW5ndGgpcmV0dXJuIEgu
-T0gobywtMSkKbS5hPW8ucG9wKCkKY29udGludWV9ZWxzZXtyPXEuYQppZihwPT09Myl0aHJvdyByCmVs
-c2V7bj1zLmEoSi5JVChyKSkKaWYobiBpbnN0YW5jZW9mIFAuR1Ype3I9bS5kCmlmKHI9PW51bGwpcj1t
-LmQ9W10KQy5ObS5pKHIsbS5hKQptLmE9bi5hCmNvbnRpbnVlfWVsc2V7bS5zWDkobikKY29udGludWV9
-fX19ZWxzZXttLnNFQyhxKQpyZXR1cm4hMH19cmV0dXJuITF9LApzRUM6ZnVuY3Rpb24oYSl7dGhpcy5i
-PXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCnNYOTpmdW5jdGlvbihhKXt0aGlzLmM9dGhpcy4kdGkuQygi
-QW48MT4/IikuYShhKX0sCiRpQW46MX0KUC5xNC5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1
-cm4gbmV3IFAuR1YodGhpcy5hKCksdGhpcy4kdGkuQygiR1Y8MT4iKSl9fQpQLkN3LnByb3RvdHlwZT17
-Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIEguRWoodGhpcy5hKX0sCiRpWFM6MSwKZ0lJOmZ1bmN0aW9uKCl7
-cmV0dXJuIHRoaXMuYn19ClAuUGYucHJvdG90eXBlPXsKdzA6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILmNi
-KGEsImVycm9yIix0LkspCnM9dGhpcy5hCmlmKHMuYSE9PTApdGhyb3cgSC5iKFAuUFYoIkZ1dHVyZSBh
-bHJlYWR5IGNvbXBsZXRlZCIpKQppZihiPT1udWxsKWI9UC52MChhKQpzLk5rKGEsYil9LApwbTpmdW5j
-dGlvbihhKXtyZXR1cm4gdGhpcy53MChhLG51bGwpfX0KUC5aZi5wcm90b3R5cGU9ewphTTpmdW5jdGlv
-bihhLGIpe3ZhciBzLHI9dGhpcy4kdGkKci5DKCIxLz8iKS5hKGIpCnM9dGhpcy5hCmlmKHMuYSE9PTAp
-dGhyb3cgSC5iKFAuUFYoIkZ1dHVyZSBhbHJlYWR5IGNvbXBsZXRlZCIpKQpzLlhmKHIuQygiMS8iKS5h
-KGIpKX19ClAuRmUucHJvdG90eXBlPXsKSFI6ZnVuY3Rpb24oYSl7aWYoKHRoaXMuYyYxNSkhPT02KXJl
-dHVybiEwCnJldHVybiB0aGlzLmIuYi5idih0LmFsLmEodGhpcy5kKSxhLmEsdC55LHQuSyl9LApLdzpm
-dW5jdGlvbihhKXt2YXIgcz10aGlzLmUscj10LnoscT10LksscD10aGlzLiR0aS5DKCIyLyIpLG89dGhp
-cy5iLmIKaWYodC5hZy5iKHMpKXJldHVybiBwLmEoby5ycChzLGEuYSxhLmIscixxLHQubCkpCmVsc2Ug
-cmV0dXJuIHAuYShvLmJ2KHQuYkkuYShzKSxhLmEscixxKSl9fQpQLnZzLnByb3RvdHlwZT17ClNxOmZ1
-bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscD10aGlzLiR0aQpwLktxKGMpLkMoIjEvKDIpIikuYShhKQpz
-PSQuWDMKaWYocyE9PUMuTlUpe2MuQygiQDwwLz4iKS5LcShwLmMpLkMoIjEoMikiKS5hKGEpCmlmKGIh
-PW51bGwpYj1QLlZIKGIscyl9cj1uZXcgUC52cyhzLGMuQygidnM8MD4iKSkKcT1iPT1udWxsPzE6Mwp0
-aGlzLnhmKG5ldyBQLkZlKHIscSxhLGIscC5DKCJAPDE+IikuS3EoYykuQygiRmU8MSwyPiIpKSkKcmV0
-dXJuIHJ9LApXNzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlNxKGEsbnVsbCxiKX0sClFkOmZ1bmN0
-aW9uKGEsYixjKXt2YXIgcyxyPXRoaXMuJHRpCnIuS3EoYykuQygiMS8oMikiKS5hKGEpCnM9bmV3IFAu
-dnMoJC5YMyxjLkMoInZzPDA+IikpCnRoaXMueGYobmV3IFAuRmUocywxOSxhLGIsci5DKCJAPDE+Iiku
-S3EoYykuQygiRmU8MSwyPiIpKSkKcmV0dXJuIHN9LAp4ZjpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMs
-cT1yLmEKaWYocTw9MSl7YS5hPXQuRi5hKHIuYykKci5jPWF9ZWxzZXtpZihxPT09Mil7cz10LmMuYShy
-LmMpCnE9cy5hCmlmKHE8NCl7cy54ZihhKQpyZXR1cm59ci5hPXEKci5jPXMuY31QLlRrKG51bGwsbnVs
-bCxyLmIsdC5NLmEobmV3IFAuZGEocixhKSkpfX0sCmpROmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8s
-bixtPXRoaXMsbD17fQpsLmE9YQppZihhPT1udWxsKXJldHVybgpzPW0uYQppZihzPD0xKXtyPXQuRi5h
-KG0uYykKbS5jPWEKaWYociE9bnVsbCl7cT1hLmEKZm9yKHA9YTtxIT1udWxsO3A9cSxxPW8pbz1xLmEK
-cC5hPXJ9fWVsc2V7aWYocz09PTIpe249dC5jLmEobS5jKQpzPW4uYQppZihzPDQpe24ualEoYSkKcmV0
-dXJufW0uYT1zCm0uYz1uLmN9bC5hPW0uTjgoYSkKUC5UayhudWxsLG51bGwsbS5iLHQuTS5hKG5ldyBQ
-Lm9RKGwsbSkpKX19LAphaDpmdW5jdGlvbigpe3ZhciBzPXQuRi5hKHRoaXMuYykKdGhpcy5jPW51bGwK
-cmV0dXJuIHRoaXMuTjgocyl9LApOODpmdW5jdGlvbihhKXt2YXIgcyxyLHEKZm9yKHM9YSxyPW51bGw7
-cyE9bnVsbDtyPXMscz1xKXtxPXMuYQpzLmE9cn1yZXR1cm4gcn0sCmVjOmZ1bmN0aW9uKGEpe3ZhciBz
-LHIscSxwPXRoaXMKcC5hPTEKdHJ5e2EuU3EobmV3IFAucFYocCksbmV3IFAuVTcocCksdC5QKX1jYXRj
-aChxKXtzPUguUnUocSkKcj1ILnRzKHEpClAucmIobmV3IFAudnIocCxzLHIpKX19LApYMjpmdW5jdGlv
-bihhKXt2YXIgcyxyPXRoaXMKci4kdGkuYy5hKGEpCnM9ci5haCgpCnIuYT00CnIuYz1hClAuSFoocixz
-KX0sClpMOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKdC5sLmEoYikKcz1xLmFoKCkKcj1QLlRs
-KGEsYikKcS5hPTgKcS5jPXIKUC5IWihxLHMpfSwKWGY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy4kdGkK
-cy5DKCIxLyIpLmEoYSkKaWYocy5DKCJiODwxPiIpLmIoYSkpe3RoaXMuY1UoYSkKcmV0dXJufXRoaXMu
-d1Uocy5jLmEoYSkpfSwKd1U6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpzLiR0aS5jLmEoYSkKcy5hPTEK
-UC5UayhudWxsLG51bGwscy5iLHQuTS5hKG5ldyBQLnJ0KHMsYSkpKX0sCmNVOmZ1bmN0aW9uKGEpe3Zh
-ciBzPXRoaXMscj1zLiR0aQpyLkMoImI4PDE+IikuYShhKQppZihyLmIoYSkpe2lmKGEuYT09PTgpe3Mu
-YT0xClAuVGsobnVsbCxudWxsLHMuYix0Lk0uYShuZXcgUC5LRihzLGEpKSl9ZWxzZSBQLkE5KGEscykK
-cmV0dXJufXMuZWMoYSl9LApOazpmdW5jdGlvbihhLGIpe3RoaXMuYT0xClAuVGsobnVsbCxudWxsLHRo
-aXMuYix0Lk0uYShuZXcgUC5aTCh0aGlzLGEsYikpKX0sCiRpYjg6MX0KUC5kYS5wcm90b3R5cGU9ewok
-MDpmdW5jdGlvbigpe1AuSFoodGhpcy5hLHRoaXMuYil9LAokUzowfQpQLm9RLnByb3RvdHlwZT17CiQw
-OmZ1bmN0aW9uKCl7UC5IWih0aGlzLmIsdGhpcy5hLmEpfSwKJFM6MH0KUC5wVi5wcm90b3R5cGU9ewok
-MTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD10aGlzLmEKcC5hPTAKdHJ5e3AuWDIocC4kdGkuYy5hKGEp
-KX1jYXRjaChxKXtzPUguUnUocSkKcj1ILnRzKHEpCnAuWkwocyxyKX19LAokUzoxMH0KUC5VNy5wcm90
-b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS5aTChhLHQubC5hKGIpKX0sCiRDOiIkMiIsCiRS
-OjIsCiRTOjI5fQpQLnZyLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRoaXMuYix0
-aGlzLmMpfSwKJFM6MH0KUC5ydC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS5YMih0aGlz
-LmIpfSwKJFM6MH0KUC5LRi5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe1AuQTkodGhpcy5iLHRoaXMu
-YSl9LAokUzowfQpQLlpMLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRoaXMuYix0
-aGlzLmMpfSwKJFM6MH0KUC5SVC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8s
-bixtPXRoaXMsbD1udWxsCnRyeXtxPW0uYS5hCmw9cS5iLmIuenoodC5mTy5hKHEuZCksdC56KX1jYXRj
-aChwKXtzPUguUnUocCkKcj1ILnRzKHApCmlmKG0uYyl7cT10Lm4uYShtLmIuYS5jKS5hCm89cwpvPXE9
-PW51bGw/bz09bnVsbDpxPT09bwpxPW99ZWxzZSBxPSExCm89bS5hCmlmKHEpby5jPXQubi5hKG0uYi5h
-LmMpCmVsc2Ugby5jPVAuVGwocyxyKQpvLmI9ITAKcmV0dXJufWlmKGwgaW5zdGFuY2VvZiBQLnZzJiZs
-LmE+PTQpe2lmKGwuYT09PTgpe3E9bS5hCnEuYz10Lm4uYShsLmMpCnEuYj0hMH1yZXR1cm59aWYodC5l
-LmIobCkpe249bS5iLmEKcT1tLmEKcS5jPWwuVzcobmV3IFAualoobiksdC56KQpxLmI9ITF9fSwKJFM6
-MH0KUC5qWi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKJFM6MzJ9ClAu
-cnEucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbSxsCnRyeXtxPXRoaXMu
-YQpwPXEuYQpvPXAuJHRpCm49by5jCm09bi5hKHRoaXMuYikKcS5jPXAuYi5iLmJ2KG8uQygiMi8oMSki
-KS5hKHAuZCksbSxvLkMoIjIvIiksbil9Y2F0Y2gobCl7cz1ILlJ1KGwpCnI9SC50cyhsKQpxPXRoaXMu
-YQpxLmM9UC5UbChzLHIpCnEuYj0hMH19LAokUzowfQpQLlJXLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9u
-KCl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRoaXMKdHJ5e3M9dC5uLmEoay5hLmEuYykKcD1rLmIKaWYo
-SC5vVChwLmEuSFIocykpJiZwLmEuZSE9bnVsbCl7cC5jPXAuYS5LdyhzKQpwLmI9ITF9fWNhdGNoKG8p
-e3I9SC5SdShvKQpxPUgudHMobykKcD10Lm4uYShrLmEuYS5jKQpuPXAuYQptPXIKbD1rLmIKaWYobj09
-bnVsbD9tPT1udWxsOm49PT1tKWwuYz1wCmVsc2UgbC5jPVAuVGwocixxKQpsLmI9ITB9fSwKJFM6MH0K
-UC5PTS5wcm90b3R5cGU9e30KUC5xaC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXt2YXIgcyxyLHE9
-dGhpcyxwPXt9LG89bmV3IFAudnMoJC5YMyx0LmZKKQpwLmE9MApzPUguTGgocSkKcj1zLkMoIn4oMSk/
-IikuYShuZXcgUC5CNShwLHEpKQp0LlouYShuZXcgUC51TyhwLG8pKQpXLkpFKHEuYSxxLmIsciwhMSxz
-LmMpCnJldHVybiBvfX0KUC5CNS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILkxoKHRoaXMuYiku
-Yy5hKGEpOysrdGhpcy5hLmF9LAokUzpmdW5jdGlvbigpe3JldHVybiBILkxoKHRoaXMuYikuQygifigx
-KSIpfX0KUC51Ty5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYixyPXMuJHRpLHE9
-ci5DKCIxLyIpLmEodGhpcy5hLmEpLHA9cy5haCgpCnIuYy5hKHEpCnMuYT00CnMuYz1xClAuSFoocyxw
-KX0sCiRTOjB9ClAuTU8ucHJvdG90eXBlPXt9ClAua1QucHJvdG90eXBlPXt9ClAueEkucHJvdG90eXBl
-PXt9ClAubTAucHJvdG90eXBlPXskaVFtOjF9ClAucEsucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2
-YXIgcz1ILmIodGhpcy5hKQpzLnN0YWNrPUouaih0aGlzLmIpCnRocm93IHN9LAokUzowfQpQLkppLnBy
-b3RvdHlwZT17CmJIOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPW51bGwKdC5NLmEoYSkKdHJ5e2lmKEMu
-TlU9PT0kLlgzKXthLiQwKCkKcmV0dXJufVAuVDgocCxwLHRoaXMsYSx0LkgpfWNhdGNoKHEpe3M9SC5S
-dShxKQpyPUgudHMocSkKUC5MMihwLHAsdGhpcyxzLHQubC5hKHIpKX19LApEbDpmdW5jdGlvbihhLGIs
-Yyl7dmFyIHMscixxLHA9bnVsbApjLkMoIn4oMCkiKS5hKGEpCmMuYShiKQp0cnl7aWYoQy5OVT09PSQu
-WDMpe2EuJDEoYikKcmV0dXJufVAueXYocCxwLHRoaXMsYSxiLHQuSCxjKX1jYXRjaChxKXtzPUguUnUo
-cSkKcj1ILnRzKHEpClAuTDIocCxwLHRoaXMscyx0LmwuYShyKSl9fSwKUlQ6ZnVuY3Rpb24oYSxiKXty
-ZXR1cm4gbmV3IFAuaGoodGhpcyxiLkMoIjAoKSIpLmEoYSksYil9LApHWTpmdW5jdGlvbihhKXtyZXR1
-cm4gbmV3IFAuVnAodGhpcyx0Lk0uYShhKSl9LApQeTpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC5P
-Uih0aGlzLGIuQygifigwKSIpLmEoYSksYil9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51bGx9LAp6
-ejpmdW5jdGlvbihhLGIpe2IuQygiMCgpIikuYShhKQppZigkLlgzPT09Qy5OVSlyZXR1cm4gYS4kMCgp
-CnJldHVybiBQLlQ4KG51bGwsbnVsbCx0aGlzLGEsYil9LApidjpmdW5jdGlvbihhLGIsYyxkKXtjLkMo
-IkA8MD4iKS5LcShkKS5DKCIxKDIpIikuYShhKQpkLmEoYikKaWYoJC5YMz09PUMuTlUpcmV0dXJuIGEu
-JDEoYikKcmV0dXJuIFAueXYobnVsbCxudWxsLHRoaXMsYSxiLGMsZCl9LApycDpmdW5jdGlvbihhLGIs
-YyxkLGUsZil7ZC5DKCJAPDA+IikuS3EoZSkuS3EoZikuQygiMSgyLDMpIikuYShhKQplLmEoYikKZi5h
-KGMpCmlmKCQuWDM9PT1DLk5VKXJldHVybiBhLiQyKGIsYykKcmV0dXJuIFAuUXgobnVsbCxudWxsLHRo
-aXMsYSxiLGMsZCxlLGYpfSwKTGo6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGIuQygiQDwwPiIpLktx
-KGMpLktxKGQpLkMoIjEoMiwzKSIpLmEoYSl9fQpQLmhqLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7
-cmV0dXJuIHRoaXMuYS56eih0aGlzLmIsdGhpcy5jKX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMu
-Yy5DKCIwKCkiKX19ClAuVnAucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmJI
-KHRoaXMuYil9LAokUzowfQpQLk9SLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
-YwpyZXR1cm4gdGhpcy5hLkRsKHRoaXMuYixzLmEoYSkscyl9LAokUzpmdW5jdGlvbigpe3JldHVybiB0
-aGlzLmMuQygifigwKSIpfX0KUC5iNi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlz
-LHI9bmV3IFAubG0ocyxzLnIsSC5MaChzKS5DKCJsbTwxPiIpKQpyLmM9cy5lCnJldHVybiByfSwKZ0E6
-ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09
-MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hIT09MH0sCnRnOmZ1bmN0aW9uKGEsYil7dmFy
-IHMscgppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIil7cz10aGlzLmIKaWYocz09
-bnVsbClyZXR1cm4hMQpyZXR1cm4gdC5tLmEoc1tiXSkhPW51bGx9ZWxzZXtyPXRoaXMuUFIoYikKcmV0
-dXJuIHJ9fSwKUFI6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJuITEKcmV0
-dXJuIHRoaXMuREYoc1t0aGlzLk4oYSldLGEpPj0wfSwKaTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT10
-aGlzCkguTGgocSkuYy5hKGIpCmlmKHR5cGVvZiBiPT0ic3RyaW5nIiYmYiE9PSJfX3Byb3RvX18iKXtz
-PXEuYgpyZXR1cm4gcS5iUShzPT1udWxsP3EuYj1QLlQyKCk6cyxiKX1lbHNlIGlmKHR5cGVvZiBiPT0i
-bnVtYmVyIiYmKGImMTA3Mzc0MTgyMyk9PT1iKXtyPXEuYwpyZXR1cm4gcS5iUShyPT1udWxsP3EuYz1Q
-LlQyKCk6cixiKX1lbHNlIHJldHVybiBxLkI3KGIpfSwKQjc6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9
-dGhpcwpILkxoKHApLmMuYShhKQpzPXAuZAppZihzPT1udWxsKXM9cC5kPVAuVDIoKQpyPXAuTihhKQpx
-PXNbcl0KaWYocT09bnVsbClzW3JdPVtwLnlvKGEpXQplbHNle2lmKHAuREYocSxhKT49MClyZXR1cm4h
-MQpxLnB1c2gocC55byhhKSl9cmV0dXJuITB9LApSOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcwppZih0
-eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIilyZXR1cm4gcy5IKHMuYixiKQplbHNlIGlm
-KHR5cGVvZiBiPT0ibnVtYmVyIiYmKGImMTA3Mzc0MTgyMyk9PT1iKXJldHVybiBzLkgocy5jLGIpCmVs
-c2UgcmV0dXJuIHMucWcoYil9LApxZzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1vLmQK
-aWYobj09bnVsbClyZXR1cm4hMQpzPW8uTihhKQpyPW5bc10KcT1vLkRGKHIsYSkKaWYocTwwKXJldHVy
-biExCnA9ci5zcGxpY2UocSwxKVswXQppZigwPT09ci5sZW5ndGgpZGVsZXRlIG5bc10Kby5HKHApCnJl
-dHVybiEwfSwKYlE6ZnVuY3Rpb24oYSxiKXtILkxoKHRoaXMpLmMuYShiKQppZih0Lm0uYShhW2JdKSE9
-bnVsbClyZXR1cm4hMQphW2JdPXRoaXMueW8oYikKcmV0dXJuITB9LApIOmZ1bmN0aW9uKGEsYil7dmFy
-IHMKaWYoYT09bnVsbClyZXR1cm4hMQpzPXQubS5hKGFbYl0pCmlmKHM9PW51bGwpcmV0dXJuITEKdGhp
-cy5HKHMpCmRlbGV0ZSBhW2JdCnJldHVybiEwfSwKUzpmdW5jdGlvbigpe3RoaXMucj10aGlzLnIrMSYx
-MDczNzQxODIzfSwKeW86ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLHE9bmV3IFAuYm4oSC5MaChyKS5j
-LmEoYSkpCmlmKHIuZT09bnVsbClyLmU9ci5mPXEKZWxzZXtzPXIuZgpzLnRvU3RyaW5nCnEuYz1zCnIu
-Zj1zLmI9cX0rK3IuYQpyLlMoKQpyZXR1cm4gcX0sCkc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPWEu
-YyxxPWEuYgppZihyPT1udWxsKXMuZT1xCmVsc2Ugci5iPXEKaWYocT09bnVsbClzLmY9cgplbHNlIHEu
-Yz1yOy0tcy5hCnMuUygpfSwKTjpmdW5jdGlvbihhKXtyZXR1cm4gSi5oZihhKSYxMDczNzQxODIzfSwK
-REY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGE9PW51bGwpcmV0dXJuLTEKcz1hLmxlbmd0aApmb3Io
-cj0wO3I8czsrK3IpaWYoSi5STShhW3JdLmEsYikpcmV0dXJuIHIKcmV0dXJuLTF9fQpQLmJuLnByb3Rv
-dHlwZT17fQpQLmxtLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVu
-Y3Rpb24oKXt2YXIgcz10aGlzLHI9cy5jLHE9cy5hCmlmKHMuYiE9PXEucil0aHJvdyBILmIoUC5hNChx
-KSkKZWxzZSBpZihyPT1udWxsKXtzLnNqKG51bGwpCnJldHVybiExfWVsc2V7cy5zaihzLiR0aS5DKCIx
-PyIpLmEoci5hKSkKcy5jPXIuYgpyZXR1cm4hMH19LApzajpmdW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4k
-dGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpQLm1XLnByb3RvdHlwZT17fQpQLnV5LnByb3RvdHlwZT17
-JGliUToxLCRpY1g6MSwkaXpNOjF9ClAubEQucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7cmV0dXJu
-IG5ldyBILmE3KGEsdGhpcy5nQShhKSxILnooYSkuQygiYTc8bEQuRT4iKSl9LApFOmZ1bmN0aW9uKGEs
-Yil7cmV0dXJuIHRoaXMucShhLGIpfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC56KGEpLkMoIn4o
-bEQuRSkiKS5hKGIpCnM9dGhpcy5nQShhKQpmb3Iocj0wO3I8czsrK3Ipe2IuJDEodGhpcy5xKGEscikp
-CmlmKHMhPT10aGlzLmdBKGEpKXRocm93IEguYihQLmE0KGEpKX19LApnbDA6ZnVuY3Rpb24oYSl7cmV0
-dXJuIHRoaXMuZ0EoYSk9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdsMChhKX0sCkUy
-OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILnooYSkKcmV0dXJuIG5ldyBILmxKKGEscy5LcShjKS5DKCIx
-KGxELkUpIikuYShiKSxzLkMoIkA8bEQuRT4iKS5LcShjKS5DKCJsSjwxLDI+IikpfSwKZVI6ZnVuY3Rp
-b24oYSxiKXtyZXR1cm4gSC5xQyhhLGIsbnVsbCxILnooYSkuQygibEQuRSIpKX0sCmRyOmZ1bmN0aW9u
-KGEsYil7cmV0dXJuIG5ldyBILmpWKGEsSC56KGEpLkMoIkA8bEQuRT4iKS5LcShiKS5DKCJqVjwxLDI+
-IikpfSwKZHU6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMKSC56KGEpLkMoImxELkU/IikuYShkKQpQLmpC
-KGIsYyx0aGlzLmdBKGEpKQpmb3Iocz1iO3M8YzsrK3MpdGhpcy5ZNShhLHMsZCl9LAp3OmZ1bmN0aW9u
-KGEpe3JldHVybiBQLldFKGEsIlsiLCJdIil9fQpQLmlsLnByb3RvdHlwZT17fQpQLnJhLnByb3RvdHlw
-ZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmEKaWYoIXIuYSl0aGlzLmIuYSs9IiwgIgpy
-LmE9ITEKcj10aGlzLmIKcz1yLmErPUguRWooYSkKci5hPXMrIjogIgpyLmErPUguRWooYil9LAokUzox
-MX0KUC5Zay5wcm90b3R5cGU9ewpLOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILkxoKHRoaXMpLkMoIn4o
-WWsuSyxZay5WKSIpLmEoYikKZm9yKHM9Si5JVCh0aGlzLmd2YygpKTtzLkYoKTspe3I9cy5nbCgpCmIu
-JDIocix0aGlzLnEoMCxyKSl9fSwKZ1B1OmZ1bmN0aW9uKGEpe3JldHVybiBKLk0xKHRoaXMuZ3ZjKCks
-bmV3IFAueVEodGhpcyksSC5MaCh0aGlzKS5DKCJOMzxZay5LLFlrLlY+IikpfSwKeDQ6ZnVuY3Rpb24o
-YSl7cmV0dXJuIEouemwodGhpcy5ndmMoKSxhKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBKLkhtKHRo
-aXMuZ3ZjKCkpfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiBKLnVVKHRoaXMuZ3ZjKCkpfSwKdzpmdW5j
-dGlvbihhKXtyZXR1cm4gUC5uTyh0aGlzKX0sCiRpWjA6MX0KUC55US5wcm90b3R5cGU9ewokMTpmdW5j
-dGlvbihhKXt2YXIgcz10aGlzLmEscj1ILkxoKHMpCnIuQygiWWsuSyIpLmEoYSkKcmV0dXJuIG5ldyBQ
-Lk4zKGEscy5xKDAsYSksci5DKCJAPFlrLks+IikuS3Eoci5DKCJZay5WIikpLkMoIk4zPDEsMj4iKSl9
-LAokUzpmdW5jdGlvbigpe3JldHVybiBILkxoKHRoaXMuYSkuQygiTjM8WWsuSyxZay5WPihZay5LKSIp
-fX0KUC5LUC5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC5MaCh0aGlzKQpzLmMu
-YShiKQpzLlFbMV0uYShjKQp0aHJvdyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSB1bm1vZGlmaWFibGUg
-bWFwIikpfX0KUC5Qbi5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS5xKDAs
-Yil9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC5MaCh0aGlzKQp0aGlzLmEuWTUoMCxzLmMuYShi
-KSxzLlFbMV0uYShjKSl9LAp4NDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLng0KGEpfSwKSzpmdW5j
-dGlvbihhLGIpe3RoaXMuYS5LKDAsSC5MaCh0aGlzKS5DKCJ+KDEsMikiKS5hKGIpKX0sCmdsMDpmdW5j
-dGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ2wwKHMpfSwKZ0E6ZnVuY3Rpb24oYSl7dmFyIHM9
-dGhpcy5hCnJldHVybiBzLmdBKHMpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gSi5qKHRoaXMuYSl9LApn
-UHU6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmdQdShzKX0sCiRpWjA6MX0KUC5Hai5w
-cm90b3R5cGU9e30KUC5sZi5wcm90b3R5cGU9ewpnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0Eo
-dGhpcyk9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpIT09MH0sCkZWOmZ1
-bmN0aW9uKGEsYil7dmFyIHMKZm9yKHM9Si5JVChILkxoKHRoaXMpLkMoImNYPGxmLkU+IikuYShiKSk7
-cy5GKCk7KXRoaXMuaSgwLHMuZ2woKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLldFKHRoaXMsInsi
-LCJ9Iil9LAprOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmdtKHRoaXMpCmlmKCFyLkYoKSlyZXR1
-cm4iIgppZihiPT09IiIpe3M9IiIKZG8gcys9SC5FaihyLmQpCndoaWxlKHIuRigpKX1lbHNle3M9SC5F
-aihyLmQpCmZvcig7ci5GKCk7KXM9cytiK0guRWooci5kKX1yZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0w
-P3M6c30sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguYksodGhpcyxiLEguTGgodGhpcykuQygibGYu
-RSIpKX0sCkU6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscD0iaW5kZXgiCkguY2IoYixwLHQuUykKUC5r
-MShiLHApCmZvcihzPXRoaXMuZ20odGhpcykscj0wO3MuRigpOyl7cT1zLmQKaWYoYj09PXIpcmV0dXJu
-IHE7KytyfXRocm93IEguYihQLkNmKGIsdGhpcyxwLG51bGwscikpfX0KUC5Wai5wcm90b3R5cGU9eyRp
-YlE6MSwkaWNYOjEsJGl4dToxfQpQLlh2LnByb3RvdHlwZT17JGliUToxLCRpY1g6MSwkaXh1OjF9ClAu
-blkucHJvdG90eXBlPXt9ClAuV1kucHJvdG90eXBlPXt9ClAuUlUucHJvdG90eXBlPXt9ClAucFIucHJv
-dG90eXBlPXt9ClAudXcucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy5iCmlm
-KHI9PW51bGwpcmV0dXJuIHRoaXMuYy5xKDAsYikKZWxzZSBpZih0eXBlb2YgYiE9InN0cmluZyIpcmV0
-dXJuIG51bGwKZWxzZXtzPXJbYl0KcmV0dXJuIHR5cGVvZiBzPT0idW5kZWZpbmVkIj90aGlzLmZiKGIp
-OnN9fSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYj09bnVsbD90aGlzLmMuYTp0aGlzLkNmKCku
-bGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpPT09MH0sCmd2YzpmdW5j
-dGlvbigpe2lmKHRoaXMuYj09bnVsbCl7dmFyIHM9dGhpcy5jCnJldHVybiBuZXcgSC5pNShzLEguTGgo
-cykuQygiaTU8MT4iKSl9cmV0dXJuIG5ldyBQLmk4KHRoaXMpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBzLHIscT10aGlzCmlmKHEuYj09bnVsbClxLmMuWTUoMCxiLGMpCmVsc2UgaWYocS54NChiKSl7cz1x
-LmIKc1tiXT1jCnI9cS5hCmlmKHI9PW51bGw/cyE9bnVsbDpyIT09cylyW2JdPW51bGx9ZWxzZSBxLlhL
-KCkuWTUoMCxiLGMpfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodGhpcy5iPT1udWxsKXJldHVybiB0aGlzLmMu
-eDQoYSkKcmV0dXJuIE9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlzLmEsYSl9
-LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz10aGlzCnQuY0EuYShiKQppZihvLmI9PW51bGwp
-cmV0dXJuIG8uYy5LKDAsYikKcz1vLkNmKCkKZm9yKHI9MDtyPHMubGVuZ3RoOysrcil7cT1zW3JdCnA9
-by5iW3FdCmlmKHR5cGVvZiBwPT0idW5kZWZpbmVkIil7cD1QLlFlKG8uYVtxXSkKby5iW3FdPXB9Yi4k
-MihxLHApCmlmKHMhPT1vLmMpdGhyb3cgSC5iKFAuYTQobykpfX0sCkNmOmZ1bmN0aW9uKCl7dmFyIHM9
-dC5iTS5hKHRoaXMuYykKaWYocz09bnVsbClzPXRoaXMuYz1ILlZNKE9iamVjdC5rZXlzKHRoaXMuYSks
-dC5zKQpyZXR1cm4gc30sClhLOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuPXRoaXMKaWYobi5iPT1u
-dWxsKXJldHVybiBuLmMKcz1QLkZsKHQuTix0LnopCnI9bi5DZigpCmZvcihxPTA7cD1yLmxlbmd0aCxx
-PHA7KytxKXtvPXJbcV0Kcy5ZNSgwLG8sbi5xKDAsbykpfWlmKHA9PT0wKUMuTm0uaShyLCIiKQplbHNl
-IEMuTm0uc0EociwwKQpuLmE9bi5iPW51bGwKcmV0dXJuIG4uYz1zfSwKZmI6ZnVuY3Rpb24oYSl7dmFy
-IHMKaWYoIU9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlzLmEsYSkpcmV0dXJu
-IG51bGwKcz1QLlFlKHRoaXMuYVthXSkKcmV0dXJuIHRoaXMuYlthXT1zfX0KUC5pOC5wcm90b3R5cGU9
-ewpnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ0Eocyl9LApFOmZ1bmN0aW9uKGEs
-Yil7dmFyIHM9dGhpcy5hCmlmKHMuYj09bnVsbClzPXMuZ3ZjKCkuRSgwLGIpCmVsc2V7cz1zLkNmKCkK
-aWYoYjwwfHxiPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGIpCnM9c1tiXX1yZXR1cm4gc30sCmdtOmZ1
-bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQppZihzLmI9PW51bGwpe3M9cy5ndmMoKQpzPXMuZ20ocyl9ZWxz
-ZXtzPXMuQ2YoKQpzPW5ldyBKLm0xKHMscy5sZW5ndGgsSC50NihzKS5DKCJtMTwxPiIpKX1yZXR1cm4g
-c30sCnRnOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS54NChiKX19ClAueHIucHJvdG90eXBlPXsK
-JDA6ZnVuY3Rpb24oKXt2YXIgcyxyCnRyeXtzPW5ldyBUZXh0RGVjb2RlcigidXRmLTgiLHtmYXRhbDp0
-cnVlfSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1yZXR1cm4gbnVsbH0sCiRTOjEyfQpQLk56LnBy
-b3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscgp0cnl7cz1uZXcgVGV4dERlY29kZXIoInV0Zi04
-Iix7ZmF0YWw6ZmFsc2V9KQpyZXR1cm4gc31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxsfSwKJFM6
-MTJ9ClAuQ1YucHJvdG90eXBlPXsKeXI6ZnVuY3Rpb24oYTAsYTEsYTIpe3ZhciBzLHIscSxwLG8sbixt
-LGwsayxqLGksaCxnLGYsZSxkLGMsYixhPSJJbnZhbGlkIGJhc2U2NCBlbmNvZGluZyBsZW5ndGggIgph
-Mj1QLmpCKGExLGEyLGEwLmxlbmd0aCkKcz0kLlY3KCkKZm9yKHI9YTEscT1yLHA9bnVsbCxvPS0xLG49
-LTEsbT0wO3I8YTI7cj1sKXtsPXIrMQprPUMueEIuVyhhMCxyKQppZihrPT09Mzcpe2o9bCsyCmlmKGo8
-PWEyKXtpPUgub28oQy54Qi5XKGEwLGwpKQpoPUgub28oQy54Qi5XKGEwLGwrMSkpCmc9aSoxNitoLSho
-JjI1NikKaWYoZz09PTM3KWc9LTEKbD1qfWVsc2UgZz0tMX1lbHNlIGc9awppZigwPD1nJiZnPD0xMjcp
-e2lmKGc8MHx8Zz49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxnKQpmPXNbZ10KaWYoZj49MCl7Zz1DLnhC
-Lk8oIkFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIz
-NDU2Nzg5Ky8iLGYpCmlmKGc9PT1rKWNvbnRpbnVlCms9Z31lbHNle2lmKGY9PT0tMSl7aWYobzwwKXtl
-PXA9PW51bGw/bnVsbDpwLmEubGVuZ3RoCmlmKGU9PW51bGwpZT0wCm89ZSsoci1xKQpuPXJ9KyttCmlm
-KGs9PT02MSljb250aW51ZX1rPWd9aWYoZiE9PS0yKXtpZihwPT1udWxsKXtwPW5ldyBQLlJuKCIiKQpl
-PXB9ZWxzZSBlPXAKZS5hKz1DLnhCLk5qKGEwLHEscikKZS5hKz1ILkx3KGspCnE9bApjb250aW51ZX19
-dGhyb3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IGRhdGEiLGEwLHIpKX1pZihwIT1udWxsKXtlPXAu
-YSs9Qy54Qi5OaihhMCxxLGEyKQpkPWUubGVuZ3RoCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxkKQpl
-bHNle2M9Qy5qbi56WShkLTEsNCkrMQppZihjPT09MSl0aHJvdyBILmIoUC5ycihhLGEwLGEyKSkKZm9y
-KDtjPDQ7KXtlKz0iPSIKcC5hPWU7KytjfX1lPXAuYQpyZXR1cm4gQy54Qi5pNyhhMCxhMSxhMixlLmNo
-YXJDb2RlQXQoMCk9PTA/ZTplKX1iPWEyLWExCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxiKQplbHNl
-e2M9Qy5qbi56WShiLDQpCmlmKGM9PT0xKXRocm93IEguYihQLnJyKGEsYTAsYTIpKQppZihjPjEpYTA9
-Qy54Qi5pNyhhMCxhMixhMixjPT09Mj8iPT0iOiI9Iil9cmV0dXJuIGEwfX0KUC5VOC5wcm90b3R5cGU9
-e30KUC5Vay5wcm90b3R5cGU9e30KUC53SS5wcm90b3R5cGU9e30KUC5aaS5wcm90b3R5cGU9e30KUC5V
-ZC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPVAucCh0aGlzLmEpCnJldHVybih0aGlzLmIh
-PW51bGw/IkNvbnZlcnRpbmcgb2JqZWN0IHRvIGFuIGVuY29kYWJsZSBvYmplY3QgZmFpbGVkOiI6IkNv
-bnZlcnRpbmcgb2JqZWN0IGRpZCBub3QgcmV0dXJuIGFuIGVuY29kYWJsZSBvYmplY3Q6IikrIiAiK3N9
-fQpQLks4LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkN5Y2xpYyBlcnJvciBpbiBKU09O
-IHN0cmluZ2lmeSJ9fQpQLmJ5LnByb3RvdHlwZT17CnBXOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwp0LmZW
-LmEoYykKcz1QLkJTKGIsdGhpcy5nSGUoKS5hKQpyZXR1cm4gc30sCk9COmZ1bmN0aW9uKGEsYil7dmFy
-IHMKdC5kQS5hKGIpCnM9UC51WChhLHRoaXMuZ1pFKCkuYixudWxsKQpyZXR1cm4gc30sCmdaRTpmdW5j
-dGlvbigpe3JldHVybiBDLm5YfSwKZ0hlOmZ1bmN0aW9uKCl7cmV0dXJuIEMuQTN9fQpQLm9qLnByb3Rv
-dHlwZT17fQpQLk14LnByb3RvdHlwZT17fQpQLlNoLnByb3RvdHlwZT17CnZwOmZ1bmN0aW9uKGEpe3Zh
-ciBzLHIscSxwLG8sbixtLGw9YS5sZW5ndGgKZm9yKHM9Si5yWShhKSxyPXRoaXMuYyxxPTAscD0wO3A8
-bDsrK3Ape289cy5XKGEscCkKaWYobz45Mil7aWYobz49NTUyOTYpe249byY2NDUxMgppZihuPT09NTUy
-OTYpe209cCsxCm09IShtPGwmJihDLnhCLlcoYSxtKSY2NDUxMik9PT01NjMyMCl9ZWxzZSBtPSExCmlm
-KCFtKWlmKG49PT01NjMyMCl7bj1wLTEKbj0hKG4+PTAmJihDLnhCLk8oYSxuKSY2NDUxMik9PT01NTI5
-Nil9ZWxzZSBuPSExCmVsc2Ugbj0hMAppZihuKXtpZihwPnEpci5hKz1DLnhCLk5qKGEscSxwKQpxPXAr
-MQpyLmErPUguTHcoOTIpCnIuYSs9SC5MdygxMTcpCnIuYSs9SC5MdygxMDApCm49bz4+PjgmMTUKci5h
-Kz1ILkx3KG48MTA/NDgrbjo4NytuKQpuPW8+Pj40JjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbikK
-bj1vJjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbil9fWNvbnRpbnVlfWlmKG88MzIpe2lmKHA+cSly
-LmErPUMueEIuTmooYSxxLHApCnE9cCsxCnIuYSs9SC5Mdyg5MikKc3dpdGNoKG8pe2Nhc2UgODpyLmEr
-PUguTHcoOTgpCmJyZWFrCmNhc2UgOTpyLmErPUguTHcoMTE2KQpicmVhawpjYXNlIDEwOnIuYSs9SC5M
-dygxMTApCmJyZWFrCmNhc2UgMTI6ci5hKz1ILkx3KDEwMikKYnJlYWsKY2FzZSAxMzpyLmErPUguTHco
-MTE0KQpicmVhawpkZWZhdWx0OnIuYSs9SC5MdygxMTcpCnIuYSs9SC5Mdyg0OCkKci5hKz1ILkx3KDQ4
-KQpuPW8+Pj40JjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbikKbj1vJjE1CnIuYSs9SC5MdyhuPDEw
-PzQ4K246ODcrbikKYnJlYWt9fWVsc2UgaWYobz09PTM0fHxvPT09OTIpe2lmKHA+cSlyLmErPUMueEIu
-TmooYSxxLHApCnE9cCsxCnIuYSs9SC5Mdyg5MikKci5hKz1ILkx3KG8pfX1pZihxPT09MClyLmErPUgu
-RWooYSkKZWxzZSBpZihxPGwpci5hKz1zLk5qKGEscSxsKX0sCkpuOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cSxwCmZvcihzPXRoaXMuYSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPXNbcV0KaWYoYT09bnVsbD9w
-PT1udWxsOmE9PT1wKXRocm93IEguYihuZXcgUC5LOChhLG51bGwpKX1DLk5tLmkocyxhKX0sCmlVOmZ1
-bmN0aW9uKGEpe3ZhciBzLHIscSxwLG89dGhpcwppZihvLnRNKGEpKXJldHVybgpvLkpuKGEpCnRyeXtz
-PW8uYi4kMShhKQppZighby50TShzKSl7cT1QLkd5KGEsbnVsbCxvLmdWSygpKQp0aHJvdyBILmIocSl9
-cT1vLmEKaWYoMD49cS5sZW5ndGgpcmV0dXJuIEguT0gocSwtMSkKcS5wb3AoKX1jYXRjaChwKXtyPUgu
-UnUocCkKcT1QLkd5KGEscixvLmdWSygpKQp0aHJvdyBILmIocSl9fSwKdE06ZnVuY3Rpb24oYSl7dmFy
-IHMscixxPXRoaXMKaWYodHlwZW9mIGE9PSJudW1iZXIiKXtpZighaXNGaW5pdGUoYSkpcmV0dXJuITEK
-cS5jLmErPUMuQ0QudyhhKQpyZXR1cm4hMH1lbHNlIGlmKGE9PT0hMCl7cS5jLmErPSJ0cnVlIgpyZXR1
-cm4hMH1lbHNlIGlmKGE9PT0hMSl7cS5jLmErPSJmYWxzZSIKcmV0dXJuITB9ZWxzZSBpZihhPT1udWxs
-KXtxLmMuYSs9Im51bGwiCnJldHVybiEwfWVsc2UgaWYodHlwZW9mIGE9PSJzdHJpbmciKXtzPXEuYwpz
-LmErPSciJwpxLnZwKGEpCnMuYSs9JyInCnJldHVybiEwfWVsc2UgaWYodC5qLmIoYSkpe3EuSm4oYSkK
-cS5sSyhhKQpzPXEuYQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnJldHVy
-biEwfWVsc2UgaWYodC5mLmIoYSkpe3EuSm4oYSkKcj1xLmp3KGEpCnM9cS5hCmlmKDA+PXMubGVuZ3Ro
-KXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcmV0dXJuIHJ9ZWxzZSByZXR1cm4hMX0sCmxLOmZ1bmN0
-aW9uKGEpe3ZhciBzLHIscT10aGlzLmMKcS5hKz0iWyIKcz1KLlU2KGEpCmlmKHMuZ29yKGEpKXt0aGlz
-LmlVKHMucShhLDApKQpmb3Iocj0xO3I8cy5nQShhKTsrK3Ipe3EuYSs9IiwiCnRoaXMuaVUocy5xKGEs
-cikpfX1xLmErPSJdIn0sCmp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMsbD17fQpp
-ZihhLmdsMChhKSl7bS5jLmErPSJ7fSIKcmV0dXJuITB9cz1hLmdBKGEpKjIKcj1QLk84KHMsbnVsbCwh
-MSx0LlcpCnE9bC5hPTAKbC5iPSEwCmEuSygwLG5ldyBQLnRpKGwscikpCmlmKCFsLmIpcmV0dXJuITEK
-cD1tLmMKcC5hKz0ieyIKZm9yKG89JyInO3E8cztxKz0yLG89JywiJyl7cC5hKz1vCm0udnAoSC5oKHJb
-cV0pKQpwLmErPSciOicKbj1xKzEKaWYobj49cylyZXR1cm4gSC5PSChyLG4pCm0uaVUocltuXSl9cC5h
-Kz0ifSIKcmV0dXJuITB9fQpQLnRpLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpp
-Zih0eXBlb2YgYSE9InN0cmluZyIpdGhpcy5hLmI9ITEKcz10aGlzLmIKcj10aGlzLmEKQy5ObS5ZNShz
-LHIuYSsrLGEpCkMuTm0uWTUocyxyLmErKyxiKX0sCiRTOjExfQpQLnR1LnByb3RvdHlwZT17CmdWSzpm
-dW5jdGlvbigpe3ZhciBzPXRoaXMuYy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfX0KUC51
-NS5wcm90b3R5cGU9ewpnWkU6ZnVuY3Rpb24oKXtyZXR1cm4gQy5Ra319ClAuRTMucHJvdG90eXBlPXsK
-V0o6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9UC5qQigwLG51bGwsYS5sZW5ndGgpLG89cC0wCmlmKG89
-PT0wKXJldHVybiBuZXcgVWludDhBcnJheSgwKQpzPW8qMwpyPW5ldyBVaW50OEFycmF5KHMpCnE9bmV3
-IFAuUncocikKaWYocS5HeChhLDAscCkhPT1wKXtKLmE2KGEscC0xKQpxLlJPKCl9cmV0dXJuIG5ldyBV
-aW50OEFycmF5KHIuc3ViYXJyYXkoMCxILnJNKDAscS5iLHMpKSl9fQpQLlJ3LnByb3RvdHlwZT17ClJP
-OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYyxxPXMuYixwPXMuYj1xKzEsbz1yLmxlbmd0aAppZihx
-Pj1vKXJldHVybiBILk9IKHIscSkKcltxXT0yMzkKcT1zLmI9cCsxCmlmKHA+PW8pcmV0dXJuIEguT0go
-cixwKQpyW3BdPTE5MQpzLmI9cSsxCmlmKHE+PW8pcmV0dXJuIEguT0gocixxKQpyW3FdPTE4OX0sCk82
-OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuPXRoaXMKaWYoKGImNjQ1MTIpPT09NTYzMjApe3M9
-NjU1MzYrKChhJjEwMjMpPDwxMCl8YiYxMDIzCnI9bi5jCnE9bi5iCnA9bi5iPXErMQpvPXIubGVuZ3Ro
-CmlmKHE+PW8pcmV0dXJuIEguT0gocixxKQpyW3FdPXM+Pj4xOHwyNDAKcT1uLmI9cCsxCmlmKHA+PW8p
-cmV0dXJuIEguT0gocixwKQpyW3BdPXM+Pj4xMiY2M3wxMjgKcD1uLmI9cSsxCmlmKHE+PW8pcmV0dXJu
-IEguT0gocixxKQpyW3FdPXM+Pj42JjYzfDEyOApuLmI9cCsxCmlmKHA+PW8pcmV0dXJuIEguT0gocixw
-KQpyW3BdPXMmNjN8MTI4CnJldHVybiEwfWVsc2V7bi5STygpCnJldHVybiExfX0sCkd4OmZ1bmN0aW9u
-KGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbSxsPXRoaXMKaWYoYiE9PWMmJihDLnhCLk8oYSxjLTEpJjY0
-NTEyKT09PTU1Mjk2KS0tYwpmb3Iocz1sLmMscj1zLmxlbmd0aCxxPWI7cTxjOysrcSl7cD1DLnhCLlco
-YSxxKQppZihwPD0xMjcpe289bC5iCmlmKG8+PXIpYnJlYWsKbC5iPW8rMQpzW29dPXB9ZWxzZXtvPXAm
-NjQ1MTIKaWYobz09PTU1Mjk2KXtpZihsLmIrND5yKWJyZWFrCm49cSsxCmlmKGwuTzYocCxDLnhCLlco
-YSxuKSkpcT1ufWVsc2UgaWYobz09PTU2MzIwKXtpZihsLmIrMz5yKWJyZWFrCmwuUk8oKX1lbHNlIGlm
-KHA8PTIwNDcpe289bC5iCm09bysxCmlmKG0+PXIpYnJlYWsKbC5iPW0KaWYobz49cilyZXR1cm4gSC5P
-SChzLG8pCnNbb109cD4+PjZ8MTkyCmwuYj1tKzEKc1ttXT1wJjYzfDEyOH1lbHNle289bC5iCmlmKG8r
-Mj49cilicmVhawptPWwuYj1vKzEKaWYobz49cilyZXR1cm4gSC5PSChzLG8pCnNbb109cD4+PjEyfDIy
-NApvPWwuYj1tKzEKaWYobT49cilyZXR1cm4gSC5PSChzLG0pCnNbbV09cD4+PjYmNjN8MTI4CmwuYj1v
-KzEKaWYobz49cilyZXR1cm4gSC5PSChzLG8pCnNbb109cCY2M3wxMjh9fX1yZXR1cm4gcX19ClAuR1ku
-cHJvdG90eXBlPXsKV0o6ZnVuY3Rpb24oYSl7dmFyIHMscgp0LkwuYShhKQpzPXRoaXMuYQpyPVAua3ko
-cyxhLDAsbnVsbCkKaWYociE9bnVsbClyZXR1cm4gcgpyZXR1cm4gbmV3IFAuYnoocykuTmUoYSwwLG51
-bGwsITApfX0KUC5iei5wcm90b3R5cGU9ewpOZTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxv
-LG49dGhpcwp0LkwuYShhKQpzPVAuakIoYixjLEouSG0oYSkpCmlmKGI9PT1zKXJldHVybiIiCnI9UC5q
-eShhLGIscykKcT1uLmhPKHIsMCxzLWIsITApCnA9bi5iCmlmKChwJjEpIT09MCl7bz1QLmo0KHApCm4u
-Yj0wCnRocm93IEguYihQLnJyKG8sYSxiK24uYykpfXJldHVybiBxfSwKaE86ZnVuY3Rpb24oYSxiLGMs
-ZCl7dmFyIHMscixxPXRoaXMKaWYoYy1iPjEwMDApe3M9Qy5qbi5CVShiK2MsMikKcj1xLmhPKGEsYixz
-LCExKQppZigocS5iJjEpIT09MClyZXR1cm4gcgpyZXR1cm4gcitxLmhPKGEscyxjLGQpfXJldHVybiBx
-LkVoKGEsYixjLGQpfSwKRWg6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRo
-aXMsaj02NTUzMyxpPWsuYixoPWsuYyxnPW5ldyBQLlJuKCIiKSxmPWIrMSxlPWEubGVuZ3RoCmlmKGI8
-MHx8Yj49ZSlyZXR1cm4gSC5PSChhLGIpCnM9YVtiXQokbGFiZWwwJDA6Zm9yKHI9ay5hOyEwOyl7Zm9y
-KDshMDtmPW8pe3E9Qy54Qi5XKCJBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
-QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
-QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUZGRkZGRkZGRkZGRkZGRkZHR0dHR0dHR0dHR0dHR0dH
-SEhISEhISEhISEhISEhISEhISEhISEhISEhISUhISEpFRUJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJC
-QkJCQktDQ0NDQ0NDQ0NDQ0NEQ0xPTk5OTUVFRUVFRUVFRUVFIixzKSYzMQpoPWk8PTMyP3MmNjE2OTQ+
-Pj5xOihzJjYzfGg8PDYpPj4+MAppPUMueEIuVygiIFx4MDAwOlhFQ0NDQ0NOOmxEYiBceDAwMDpYRUND
-Q0NDTnZsRGIgXHgwMDA6WEVDQ0NDQ046bERiIEFBQUFBXHgwMFx4MDBceDAwXHgwMFx4MDBBQUFBQTAw
-MDAwQUFBQUE6Ojo6OkFBQUFBR0cwMDBBQUFBQTAwS0tLQUFBQUFHOjo6OkFBQUFBOklJSUlBQUFBQTAw
-MFx4ODAwQUFBQUFceDAwXHgwMFx4MDBceDAwIEFBQUFBIixpK3EpCmlmKGk9PT0wKXtnLmErPUguTHco
-aCkKaWYoZj09PWMpYnJlYWsgJGxhYmVsMCQwCmJyZWFrfWVsc2UgaWYoKGkmMSkhPT0wKXtpZihyKXN3
-aXRjaChpKXtjYXNlIDY5OmNhc2UgNjc6Zy5hKz1ILkx3KGopCmJyZWFrCmNhc2UgNjU6Zy5hKz1ILkx3
-KGopOy0tZgpicmVhawpkZWZhdWx0OnA9Zy5hKz1ILkx3KGopCmcuYT1wK0guTHcoaikKYnJlYWt9ZWxz
-ZXtrLmI9aQprLmM9Zi0xCnJldHVybiIifWk9MH1pZihmPT09YylicmVhayAkbGFiZWwwJDAKbz1mKzEK
-aWYoZjwwfHxmPj1lKXJldHVybiBILk9IKGEsZikKcz1hW2ZdfW89ZisxCmlmKGY8MHx8Zj49ZSlyZXR1
-cm4gSC5PSChhLGYpCnM9YVtmXQppZihzPDEyOCl7d2hpbGUoITApe2lmKCEobzxjKSl7bj1jCmJyZWFr
-fW09bysxCmlmKG88MHx8bz49ZSlyZXR1cm4gSC5PSChhLG8pCnM9YVtvXQppZihzPj0xMjgpe249bS0x
-Cm89bQpicmVha31vPW19aWYobi1mPDIwKWZvcihsPWY7bDxuOysrbCl7aWYobD49ZSlyZXR1cm4gSC5P
-SChhLGwpCmcuYSs9SC5MdyhhW2xdKX1lbHNlIGcuYSs9UC5ITShhLGYsbikKaWYobj09PWMpYnJlYWsg
-JGxhYmVsMCQwCmY9b31lbHNlIGY9b31pZihkJiZpPjMyKWlmKHIpZy5hKz1ILkx3KGopCmVsc2V7ay5i
-PTc3CmsuYz1jCnJldHVybiIifWsuYj1pCmsuYz1oCmU9Zy5hCnJldHVybiBlLmNoYXJDb2RlQXQoMCk9
-PTA/ZTplfX0KUC5XRi5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQp0LmZvLmEo
-YSkKcz10aGlzLmIKcj10aGlzLmEKcy5hKz1yLmEKcT1zLmErPUguRWooYS5hKQpzLmE9cSsiOiAiCnMu
-YSs9UC5wKGIpCnIuYT0iLCAifSwKJFM6NDJ9ClAuaVAucHJvdG90eXBlPXsKRE46ZnVuY3Rpb24oYSxi
-KXtpZihiPT1udWxsKXJldHVybiExCnJldHVybiBiIGluc3RhbmNlb2YgUC5pUCYmdGhpcy5hPT09Yi5h
-JiYhMH0sCmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuKHNeQy5qbi53RyhzLDMwKSkm
-MTA3Mzc0MTgyM30sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPVAuR3EoSC50SihzKSkscT1QLmgw
-KEguTlMocykpLHA9UC5oMChILmpBKHMpKSxvPVAuaDAoSC5JWChzKSksbj1QLmgwKEguY2gocykpLG09
-UC5oMChILkpkKHMpKSxsPVAuVngoSC5vMShzKSksaz1yKyItIitxKyItIitwKyIgIitvKyI6IituKyI6
-IittKyIuIitsCnJldHVybiBrfX0KUC5YUy5wcm90b3R5cGU9ewpnSUk6ZnVuY3Rpb24oKXtyZXR1cm4g
-SC50cyh0aGlzLiR0aHJvd25Kc0Vycm9yKX19ClAuQzYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2
-YXIgcz10aGlzLmEKaWYocyE9bnVsbClyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDogIitQLnAocykKcmV0
-dXJuIkFzc2VydGlvbiBmYWlsZWQifX0KUC5Fei5wcm90b3R5cGU9e30KUC5GLnByb3RvdHlwZT17Cnc6
-ZnVuY3Rpb24oYSl7cmV0dXJuIlRocm93IG9mIG51bGwuIn19ClAudS5wcm90b3R5cGU9ewpnWjpmdW5j
-dGlvbigpe3JldHVybiJJbnZhbGlkIGFyZ3VtZW50IisoIXRoaXMuYT8iKHMpIjoiIil9LApndTpmdW5j
-dGlvbigpe3JldHVybiIifSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxwPXEuYyxvPXA9PW51
-bGw/IiI6IiAoIitwKyIpIixuPXEuZCxtPW49PW51bGw/IiI6IjogIitILkVqKG4pLGw9cS5nWigpK28r
-bQppZighcS5hKXJldHVybiBsCnM9cS5ndSgpCnI9UC5wKHEuYikKcmV0dXJuIGwrcysiOiAiK3J9fQpQ
-LmJKLnByb3RvdHlwZT17CmdaOmZ1bmN0aW9uKCl7cmV0dXJuIlJhbmdlRXJyb3IifSwKZ3U6ZnVuY3Rp
-b24oKXt2YXIgcyxyPXRoaXMuZSxxPXRoaXMuZgppZihyPT1udWxsKXM9cSE9bnVsbD8iOiBOb3QgbGVz
-cyB0aGFuIG9yIGVxdWFsIHRvICIrSC5FaihxKToiIgplbHNlIGlmKHE9PW51bGwpcz0iOiBOb3QgZ3Jl
-YXRlciB0aGFuIG9yIGVxdWFsIHRvICIrSC5FaihyKQplbHNlIGlmKHE+cilzPSI6IE5vdCBpbiBpbmNs
-dXNpdmUgcmFuZ2UgIitILkVqKHIpKyIuLiIrSC5FaihxKQplbHNlIHM9cTxyPyI6IFZhbGlkIHZhbHVl
-IHJhbmdlIGlzIGVtcHR5IjoiOiBPbmx5IHZhbGlkIHZhbHVlIGlzICIrSC5FaihyKQpyZXR1cm4gc319
-ClAuZVkucHJvdG90eXBlPXsKZ1o6ZnVuY3Rpb24oKXtyZXR1cm4iUmFuZ2VFcnJvciJ9LApndTpmdW5j
-dGlvbigpe3ZhciBzLHI9SC51UCh0aGlzLmIpCmlmKHR5cGVvZiByIT09Im51bWJlciIpcmV0dXJuIHIu
-SigpCmlmKHI8MClyZXR1cm4iOiBpbmRleCBtdXN0IG5vdCBiZSBuZWdhdGl2ZSIKcz10aGlzLmYKaWYo
-cz09PTApcmV0dXJuIjogbm8gaW5kaWNlcyBhcmUgdmFsaWQiCnJldHVybiI6IGluZGV4IHNob3VsZCBi
-ZSBsZXNzIHRoYW4gIitILkVqKHMpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZn19ClAubXAu
-cHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhpcyxqPXt9LGk9
-bmV3IFAuUm4oIiIpCmouYT0iIgpzPWsuYwpmb3Iocj1zLmxlbmd0aCxxPTAscD0iIixvPSIiO3E8cjsr
-K3Esbz0iLCAiKXtuPXNbcV0KaS5hPXArbwpwPWkuYSs9UC5wKG4pCmouYT0iLCAifWsuZC5LKDAsbmV3
-IFAuV0YoaixpKSkKbT1QLnAoay5hKQpsPWkudygwKQpyPSJOb1N1Y2hNZXRob2RFcnJvcjogbWV0aG9k
-IG5vdCBmb3VuZDogJyIrSC5FaihrLmIuYSkrIidcblJlY2VpdmVyOiAiK20rIlxuQXJndW1lbnRzOiBb
-IitsKyJdIgpyZXR1cm4gcn19ClAudWIucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iVW5z
-dXBwb3J0ZWQgb3BlcmF0aW9uOiAiK3RoaXMuYX19ClAuZHMucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
-KXt2YXIgcz10aGlzLmEKcmV0dXJuIHMhPW51bGw/IlVuaW1wbGVtZW50ZWRFcnJvcjogIitzOiJVbmlt
-cGxlbWVudGVkRXJyb3IifX0KUC5sai5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJCYWQg
-c3RhdGU6ICIrdGhpcy5hfX0KUC5VVi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
-YQppZihzPT1udWxsKXJldHVybiJDb25jdXJyZW50IG1vZGlmaWNhdGlvbiBkdXJpbmcgaXRlcmF0aW9u
-LiIKcmV0dXJuIkNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uIGR1cmluZyBpdGVyYXRpb246ICIrUC5wKHMp
-KyIuIn19ClAuazUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iT3V0IG9mIE1lbW9yeSJ9
-LApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4gbnVsbH0sCiRpWFM6MX0KUC5LWS5wcm90b3R5cGU9ewp3OmZ1
-bmN0aW9uKGEpe3JldHVybiJTdGFjayBPdmVyZmxvdyJ9LApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4gbnVs
-bH0sCiRpWFM6MX0KUC5jLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVy
-biBzPT1udWxsPyJSZWFkaW5nIHN0YXRpYyB2YXJpYWJsZSBkdXJpbmcgaXRzIGluaXRpYWxpemF0aW9u
-IjoiUmVhZGluZyBzdGF0aWMgdmFyaWFibGUgJyIrcysiJyBkdXJpbmcgaXRzIGluaXRpYWxpemF0aW9u
-In19ClAuQ0QucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iRXhjZXB0aW9uOiAiK3RoaXMu
-YX0sCiRpUno6MX0KUC5hRS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixt
-LGwsayxqLGksaCxnPXRoaXMuYSxmPWchPW51bGwmJiIiIT09Zz8iRm9ybWF0RXhjZXB0aW9uOiAiK0gu
-RWooZyk6IkZvcm1hdEV4Y2VwdGlvbiIsZT10aGlzLmMsZD10aGlzLmIKaWYodHlwZW9mIGQ9PSJzdHJp
-bmciKXtpZihlIT1udWxsKXM9ZTwwfHxlPmQubGVuZ3RoCmVsc2Ugcz0hMQppZihzKWU9bnVsbAppZihl
-PT1udWxsKXtpZihkLmxlbmd0aD43OClkPUMueEIuTmooZCwwLDc1KSsiLi4uIgpyZXR1cm4gZisiXG4i
-K2R9Zm9yKHI9MSxxPTAscD0hMSxvPTA7bzxlOysrbyl7bj1DLnhCLlcoZCxvKQppZihuPT09MTApe2lm
-KHEhPT1vfHwhcCkrK3IKcT1vKzEKcD0hMX1lbHNlIGlmKG49PT0xMyl7KytyCnE9bysxCnA9ITB9fWY9
-cj4xP2YrKCIgKGF0IGxpbmUgIityKyIsIGNoYXJhY3RlciAiKyhlLXErMSkrIilcbiIpOmYrKCIgKGF0
-IGNoYXJhY3RlciAiKyhlKzEpKyIpXG4iKQptPWQubGVuZ3RoCmZvcihvPWU7bzxtOysrbyl7bj1DLnhC
-Lk8oZCxvKQppZihuPT09MTB8fG49PT0xMyl7bT1vCmJyZWFrfX1pZihtLXE+NzgpaWYoZS1xPDc1KXts
-PXErNzUKaz1xCmo9IiIKaT0iLi4uIn1lbHNle2lmKG0tZTw3NSl7az1tLTc1Cmw9bQppPSIifWVsc2V7
-az1lLTM2Cmw9ZSszNgppPSIuLi4ifWo9Ii4uLiJ9ZWxzZXtsPW0Kaz1xCmo9IiIKaT0iIn1oPUMueEIu
-TmooZCxrLGwpCnJldHVybiBmK2oraCtpKyJcbiIrQy54Qi5UKCIgIixlLWsrai5sZW5ndGgpKyJeXG4i
-fWVsc2UgcmV0dXJuIGUhPW51bGw/ZisoIiAoYXQgb2Zmc2V0ICIrSC5FaihlKSsiKSIpOmZ9LAokaVJ6
-OjF9ClAuY1gucHJvdG90eXBlPXsKZHI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5HSih0aGlzLEguTGgo
-dGhpcykuQygiY1guRSIpLGIpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0
-dXJuIEguSzEodGhpcyxzLktxKGMpLkMoIjEoY1guRSkiKS5hKGIpLHMuQygiY1guRSIpLGMpfSwKZXY6
-ZnVuY3Rpb24oYSxiKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVybiBuZXcgSC5VNSh0aGlzLHMuQygiYTIo
-Y1guRSkiKS5hKGIpLHMuQygiVTU8Y1guRT4iKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVybiBQLlkx
-KHRoaXMsYixILkxoKHRoaXMpLkMoImNYLkUiKSl9LApicjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy50
-dChhLCEwKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5nbSh0aGlzKQpmb3Iocz0wO3IuRigp
-OykrK3MKcmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIXRoaXMuZ20odGhpcykuRigpfSwK
-Z29yOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdsMCh0aGlzKX0sCmVSOmZ1bmN0aW9uKGEsYil7cmV0
-dXJuIEguYksodGhpcyxiLEguTGgodGhpcykuQygiY1guRSIpKX0sCmdyODpmdW5jdGlvbihhKXt2YXIg
-cyxyPXRoaXMuZ20odGhpcykKaWYoIXIuRigpKXRocm93IEguYihILldwKCkpCnM9ci5nbCgpCmlmKHIu
-RigpKXRocm93IEguYihILkFtKCkpCnJldHVybiBzfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpQ
-LmsxKGIsImluZGV4IikKZm9yKHM9dGhpcy5nbSh0aGlzKSxyPTA7cy5GKCk7KXtxPXMuZ2woKQppZihi
-PT09cilyZXR1cm4gcTsrK3J9dGhyb3cgSC5iKFAuQ2YoYix0aGlzLCJpbmRleCIsbnVsbCxyKSl9LAp3
-OmZ1bmN0aW9uKGEpe3JldHVybiBQLkVQKHRoaXMsIigiLCIpIil9fQpQLkFuLnByb3RvdHlwZT17fQpQ
-Lk4zLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk1hcEVudHJ5KCIrSC5FaihKLmoodGhp
-cy5hKSkrIjogIitILkVqKEouaih0aGlzLmIpKSsiKSJ9fQpQLmM4LnByb3RvdHlwZT17CmdpTzpmdW5j
-dGlvbihhKXtyZXR1cm4gUC5NaC5wcm90b3R5cGUuZ2lPLmNhbGwoQy5qTix0aGlzKX0sCnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIm51bGwifX0KUC5NaC5wcm90b3R5cGU9e2NvbnN0cnVjdG9yOlAuTWgsJGlNaDox
-LApETjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzPT09Yn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4g
-SC5lUSh0aGlzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5NKHRo
-aXMpKSsiJyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKHRoaXMsYi5n
-V2EoKSxiLmduZCgpLGIuZ1ZtKCkpKX0sCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMudyh0
-aGlzKX19ClAuWmQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iIn0sCiRpR3o6MX0KUC5S
-bi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnc6ZnVuY3Rp
-b24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwKJGlCTDoxfQpQ
-Lm4xLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5KLmEoYSkKSC5oKGIp
-CnM9Si5yWShiKS5PWShiLCI9IikKaWYocz09PS0xKXtpZihiIT09IiIpYS5ZNSgwLFAua3UoYiwwLGIu
-bGVuZ3RoLHRoaXMuYSwhMCksIiIpfWVsc2UgaWYocyE9PTApe3I9Qy54Qi5OaihiLDAscykKcT1DLnhC
-LnluKGIscysxKQpwPXRoaXMuYQphLlk1KDAsUC5rdShyLDAsci5sZW5ndGgscCwhMCksUC5rdShxLDAs
-cS5sZW5ndGgscCwhMCkpfXJldHVybiBhfSwKJFM6NDR9ClAuY1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rp
-b24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxsZWdhbCBJUHY0IGFkZHJlc3MsICIrYSx0aGlzLmEsYikp
-fSwKJFM6MjF9ClAuVkMucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigi
-SWxsZWdhbCBJUHY2IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJDE6ZnVuY3Rpb24oYSl7cmV0dXJu
-IHRoaXMuJDIoYSxudWxsKX0sCiRTOjQ3fQpQLkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7
-dmFyIHMKaWYoYi1hPjQpdGhpcy5hLiQyKCJhbiBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFpbiBhIG1h
-eGltdW0gb2YgNCBoZXggZGlnaXRzIixhKQpzPVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwxNikKaWYo
-czwwfHxzPjY1NTM1KXRoaXMuYS4kMigiZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIG9mIGAw
-eDAuLjB4RkZGRmAiLGEpCnJldHVybiBzfSwKJFM6NTF9ClAuRG4ucHJvdG90eXBlPXsKZ25EOmZ1bmN0
-aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlmKCFvLnkpe3M9by5hCnI9cy5sZW5ndGghPT0wP3MrIjoi
-OiIiCnE9by5jCnA9cT09bnVsbAppZighcHx8cz09PSJmaWxlIil7cz1yKyIvLyIKcj1vLmIKaWYoci5s
-ZW5ndGghPT0wKXM9cytyKyJAIgppZighcClzKz1xCnI9by5kCmlmKHIhPW51bGwpcz1zKyI6IitILkVq
-KHIpfWVsc2Ugcz1yCnMrPW8uZQpyPW8uZgppZihyIT1udWxsKXM9cysiPyIrcgpyPW8ucgppZihyIT1u
-dWxsKXM9cysiIyIrcgppZihvLnkpdGhyb3cgSC5iKEguR1EoIl90ZXh0IikpCm8ueD1zLmNoYXJDb2Rl
-QXQoMCk9PTA/czpzCm8ueT0hMH1yZXR1cm4gby54fSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRo
-aXMKaWYoIXEuUSl7cz1xLmUKaWYocy5sZW5ndGghPT0wJiZDLnhCLlcocywwKT09PTQ3KXM9Qy54Qi55
-bihzLDEpCnI9cy5sZW5ndGg9PT0wP0MueEQ6UC5BRihuZXcgSC5sSihILlZNKHMuc3BsaXQoIi8iKSx0
-LnMpLHQuZE8uYShQLlBIKCkpLHQuZG8pLHQuTikKaWYocS5RKXRocm93IEguYihILkdRKCJwYXRoU2Vn
-bWVudHMiKSkKcS5zS3AocikKcS5RPSEwfXJldHVybiBxLnp9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMs
-cj10aGlzCmlmKCFyLmN4KXtzPUouaGYoci5nbkQoKSkKaWYoci5jeCl0aHJvdyBILmIoSC5HUSgiaGFz
-aENvZGUiKSkKci5jaD1zCnIuY3g9ITB9cmV0dXJuIHIuY2h9LApnaFk6ZnVuY3Rpb24oKXt2YXIgcyxy
-PXRoaXMKaWYoIXIuZGIpe3M9UC5XWChyLmd0UCgpKQppZihyLmRiKXRocm93IEguYihILkdRKCJxdWVy
-eVBhcmFtZXRlcnMiKSkKci5zTk0obmV3IFAuR2oocyx0LmR3KSkKci5kYj0hMH1yZXR1cm4gci5jeX0s
-CmdrdTpmdW5jdGlvbigpe3JldHVybiB0aGlzLmJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5j
-CmlmKHM9PW51bGwpcmV0dXJuIiIKaWYoQy54Qi5uKHMsIlsiKSlyZXR1cm4gQy54Qi5OaihzLDEscy5s
-ZW5ndGgtMSkKcmV0dXJuIHN9LApndHA6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCnJldHVybiBzPT1u
-dWxsP1Aud0sodGhpcy5hKTpzfSwKZ3RQOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5mCnJldHVybiBzPT1u
-dWxsPyIiOnN9LApnS2E6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLnIKcmV0dXJuIHM9PW51bGw/IiI6c30s
-Cm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGo9dGhpcwp0LmM5LmEoYikKcz1q
-LmEKcj1zPT09ImZpbGUiCnE9ai5iCnA9ai5kCm89ai5jCmlmKCEobyE9bnVsbCkpbz1xLmxlbmd0aCE9
-PTB8fHAhPW51bGx8fHI/IiI6bnVsbApuPWouZQppZighciltPW8hPW51bGwmJm4ubGVuZ3RoIT09MApl
-bHNlIG09ITAKaWYobSYmIUMueEIubihuLCIvIikpbj0iLyIrbgpsPW4Kaz1QLmxlKG51bGwsMCwwLGIp
-CnJldHVybiBuZXcgUC5EbihzLHEsbyxwLGwsayxqLnIpfSwKSmg6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
-LHEscCxvLG4KZm9yKHM9MCxyPTA7Qy54Qi5RaShiLCIuLi8iLHIpOyl7cis9MzsrK3N9cT1DLnhCLmNu
-KGEsIi8iKQp3aGlsZSghMCl7aWYoIShxPjAmJnM+MCkpYnJlYWsKcD1DLnhCLlBrKGEsIi8iLHEtMSkK
-aWYocDwwKWJyZWFrCm89cS1wCm49byE9PTIKaWYoIW58fG89PT0zKWlmKEMueEIuTyhhLHArMSk9PT00
-NiluPSFufHxDLnhCLk8oYSxwKzIpPT09NDYKZWxzZSBuPSExCmVsc2Ugbj0hMQppZihuKWJyZWFrOy0t
-cwpxPXB9cmV0dXJuIEMueEIuaTcoYSxxKzEsbnVsbCxDLnhCLnluKGIsci0zKnMpKX0sClpJOmZ1bmN0
-aW9uKGEpe3JldHVybiB0aGlzLm1TKFAuaEsoYSkpfSwKbVM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAs
-byxuLG0sbCxrLGo9dGhpcyxpPW51bGwKaWYoYS5nRmkoKS5sZW5ndGghPT0wKXtzPWEuZ0ZpKCkKaWYo
-YS5nY2ooKSl7cj1hLmdrdSgpCnE9YS5nSmYoYSkKcD1hLmd4QSgpP2EuZ3RwKGEpOml9ZWxzZXtwPWkK
-cT1wCnI9IiJ9bz1QLnhlKGEuZ0lpKGEpKQpuPWEuZ1FEKCk/YS5ndFAoKTppfWVsc2V7cz1qLmEKaWYo
-YS5nY2ooKSl7cj1hLmdrdSgpCnE9YS5nSmYoYSkKcD1QLndCKGEuZ3hBKCk/YS5ndHAoYSk6aSxzKQpv
-PVAueGUoYS5nSWkoYSkpCm49YS5nUUQoKT9hLmd0UCgpOml9ZWxzZXtyPWouYgpxPWouYwpwPWouZApp
-ZihhLmdJaShhKT09PSIiKXtvPWouZQpuPWEuZ1FEKCk/YS5ndFAoKTpqLmZ9ZWxzZXtpZihhLmd0VCgp
-KW89UC54ZShhLmdJaShhKSkKZWxzZXttPWouZQppZihtLmxlbmd0aD09PTApaWYocT09bnVsbClvPXMu
-bGVuZ3RoPT09MD9hLmdJaShhKTpQLnhlKGEuZ0lpKGEpKQplbHNlIG89UC54ZSgiLyIrYS5nSWkoYSkp
-CmVsc2V7bD1qLkpoKG0sYS5nSWkoYSkpCms9cy5sZW5ndGg9PT0wCmlmKCFrfHxxIT1udWxsfHxDLnhC
-Lm4obSwiLyIpKW89UC54ZShsKQplbHNlIG89UC53RihsLCFrfHxxIT1udWxsKX19bj1hLmdRRCgpP2Eu
-Z3RQKCk6aX19fXJldHVybiBuZXcgUC5EbihzLHIscSxwLG8sbixhLmdaOCgpP2EuZ0thKCk6aSl9LApn
-Y2o6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5jIT1udWxsfSwKZ3hBOmZ1bmN0aW9uKCl7cmV0dXJuIHRo
-aXMuZCE9bnVsbH0sCmdRRDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmYhPW51bGx9LApnWjg6ZnVuY3Rp
-b24oKXtyZXR1cm4gdGhpcy5yIT1udWxsfSwKZ3RUOmZ1bmN0aW9uKCl7cmV0dXJuIEMueEIubih0aGlz
-LmUsIi8iKX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5hCmlmKHEhPT0iIiYmcSE9PSJm
-aWxlIil0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBhICIrcSsi
-IFVSSSIpKQppZihyLmd0UCgpIT09IiIpdGhyb3cgSC5iKFAuTDQodS5pKSkKaWYoci5nS2EoKSE9PSIi
-KXRocm93IEguYihQLkw0KHUubCkpCnE9JC53USgpCmlmKEgub1QocSkpcT1QLm1uKHIpCmVsc2V7aWYo
-ci5jIT1udWxsJiZyLmdKZihyKSE9PSIiKUgudihQLkw0KHUuaikpCnM9ci5nRmooKQpQLmtFKHMsITEp
-CnE9UC52ZyhDLnhCLm4oci5lLCIvIik/Ii8iOiIiLHMsIi8iKQpxPXEuY2hhckNvZGVBdCgwKT09MD9x
-OnF9cmV0dXJuIHF9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmduRCgpfSwKRE46ZnVuY3Rpb24o
-YSxiKXt2YXIgcz10aGlzCmlmKGI9PW51bGwpcmV0dXJuITEKaWYocz09PWIpcmV0dXJuITAKcmV0dXJu
-IHQuZEQuYihiKSYmcy5hPT09Yi5nRmkoKSYmcy5jIT1udWxsPT09Yi5nY2ooKSYmcy5iPT09Yi5na3Uo
-KSYmcy5nSmYocyk9PT1iLmdKZihiKSYmcy5ndHAocyk9PT1iLmd0cChiKSYmcy5lPT09Yi5nSWkoYikm
-JnMuZiE9bnVsbD09PWIuZ1FEKCkmJnMuZ3RQKCk9PT1iLmd0UCgpJiZzLnIhPW51bGw9PT1iLmdaOCgp
-JiZzLmdLYSgpPT09Yi5nS2EoKX0sCnNLcDpmdW5jdGlvbihhKXt0aGlzLno9dC5iay5hKGEpfSwKc05N
-OmZ1bmN0aW9uKGEpe3RoaXMuY3k9dC5jWi5hKGEpfSwKJGlpRDoxLApnRmk6ZnVuY3Rpb24oKXtyZXR1
-cm4gdGhpcy5hfSwKZ0lpOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmV9fQpQLlJaLnByb3RvdHlwZT17
-CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBQLmVQKEMuWkosSC5oKGEpLEMueE0sITEpfSwKJFM6NX0KUC5N
-RS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMuYixyPXRoaXMuYQpzLmErPXIu
-YQpyLmE9IiYiCnI9cy5hKz1ILkVqKFAuZVAoQy5GMyxhLEMueE0sITApKQppZihiIT1udWxsJiZiLmxl
-bmd0aCE9PTApe3MuYT1yKyI9IgpzLmErPUguRWooUC5lUChDLkYzLGIsQy54TSwhMCkpfX0sCiRTOjIy
-fQpQLnk1LnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILmgoYSkKaWYoYj09bnVs
-bHx8dHlwZW9mIGI9PSJzdHJpbmciKXRoaXMuYS4kMihhLEguayhiKSkKZWxzZSBmb3Iocz1KLklUKHQu
-dS5hKGIpKSxyPXRoaXMuYTtzLkYoKTspci4kMihhLEguaChzLmdsKCkpKX0sCiRTOjEzfQpQLlBFLnBy
-b3RvdHlwZT17CmdsUjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89dGhpcyxuPW51bGwsbT1vLmMKaWYo
-bT09bnVsbCl7bT1vLmIKaWYoMD49bS5sZW5ndGgpcmV0dXJuIEguT0gobSwwKQpzPW8uYQptPW1bMF0r
-MQpyPUMueEIuWFUocywiPyIsbSkKcT1zLmxlbmd0aAppZihyPj0wKXtwPVAuUEkocyxyKzEscSxDLlZD
-LCExKQpxPXJ9ZWxzZSBwPW4KbT1vLmM9bmV3IFAucWUoImRhdGEiLCIiLG4sbixQLlBJKHMsbSxxLEMu
-V2QsITEpLHAsbil9cmV0dXJuIG19LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5iCmlmKDA+PXIu
-bGVuZ3RoKXJldHVybiBILk9IKHIsMCkKcz10aGlzLmEKcmV0dXJuIHJbMF09PT0tMT8iZGF0YToiK3M6
-c319ClAueUkucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmEKaWYoYT49cy5s
-ZW5ndGgpcmV0dXJuIEguT0gocyxhKQpzPXNbYV0KQy5OQS5kdShzLDAsOTYsYikKcmV0dXJuIHN9LAok
-UzoyM30KUC5jNi5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxCmZvcihzPWIu
-bGVuZ3RoLHI9MDtyPHM7KytyKXtxPUMueEIuVyhiLHIpXjk2CmlmKHE+PTk2KXJldHVybiBILk9IKGEs
-cSkKYVtxXT1jfX0sCiRTOjE0fQpQLnFkLnByb3RvdHlwZT17CiQzOmZ1bmN0aW9uKGEsYixjKXt2YXIg
-cyxyLHEKZm9yKHM9Qy54Qi5XKGIsMCkscj1DLnhCLlcoYiwxKTtzPD1yOysrcyl7cT0oc145Nik+Pj4w
-CmlmKHE+PTk2KXJldHVybiBILk9IKGEscSkKYVtxXT1jfX0sCiRTOjE0fQpQLlVmLnByb3RvdHlwZT17
-CmdjajpmdW5jdGlvbigpe3JldHVybiB0aGlzLmM+MH0sCmd4QTpmdW5jdGlvbigpe3JldHVybiB0aGlz
-LmM+MCYmdGhpcy5kKzE8dGhpcy5lfSwKZ1FEOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZjx0aGlzLnJ9
-LApnWjg6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yPHRoaXMuYS5sZW5ndGh9LApnTnc6ZnVuY3Rpb24o
-KXtyZXR1cm4gdGhpcy5iPT09NCYmQy54Qi5uKHRoaXMuYSwiZmlsZSIpfSwKZ1daOmZ1bmN0aW9uKCl7
-cmV0dXJuIHRoaXMuYj09PTQmJkMueEIubih0aGlzLmEsImh0dHAiKX0sCmdSZTpmdW5jdGlvbigpe3Jl
-dHVybiB0aGlzLmI9PT01JiZDLnhCLm4odGhpcy5hLCJodHRwcyIpfSwKZ3RUOmZ1bmN0aW9uKCl7cmV0
-dXJuIEMueEIuUWkodGhpcy5hLCIvIix0aGlzLmUpfSwKZ0ZpOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy54
-CnJldHVybiBzPT1udWxsP3RoaXMueD10aGlzLlUyKCk6c30sClUyOmZ1bmN0aW9uKCl7dmFyIHM9dGhp
-cyxyPXMuYgppZihyPD0wKXJldHVybiIiCmlmKHMuZ1daKCkpcmV0dXJuImh0dHAiCmlmKHMuZ1JlKCkp
-cmV0dXJuImh0dHBzIgppZihzLmdOdygpKXJldHVybiJmaWxlIgppZihyPT09NyYmQy54Qi5uKHMuYSwi
-cGFja2FnZSIpKXJldHVybiJwYWNrYWdlIgpyZXR1cm4gQy54Qi5OaihzLmEsMCxyKX0sCmdrdTpmdW5j
-dGlvbigpe3ZhciBzPXRoaXMuYyxyPXRoaXMuYiszCnJldHVybiBzPnI/Qy54Qi5Oaih0aGlzLmEscixz
-LTEpOiIifSwKZ0pmOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYwpyZXR1cm4gcz4wP0MueEIuTmoodGhp
-cy5hLHMsdGhpcy5kKToiIn0sCmd0cDpmdW5jdGlvbihhKXt2YXIgcz10aGlzCmlmKHMuZ3hBKCkpcmV0
-dXJuIFAuUUEoQy54Qi5OaihzLmEscy5kKzEscy5lKSxudWxsKQppZihzLmdXWigpKXJldHVybiA4MApp
-ZihzLmdSZSgpKXJldHVybiA0NDMKcmV0dXJuIDB9LApnSWk6ZnVuY3Rpb24oYSl7cmV0dXJuIEMueEIu
-TmoodGhpcy5hLHRoaXMuZSx0aGlzLmYpfSwKZ3RQOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5mLHI9dGhp
-cy5yCnJldHVybiBzPHI/Qy54Qi5Oaih0aGlzLmEscysxLHIpOiIifSwKZ0thOmZ1bmN0aW9uKCl7dmFy
-IHM9dGhpcy5yLHI9dGhpcy5hCnJldHVybiBzPHIubGVuZ3RoP0MueEIueW4ocixzKzEpOiIifSwKZ0Zq
-OmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMuZSxwPXRoaXMuZixvPXRoaXMuYQppZihDLnhCLlFpKG8s
-Ii8iLHEpKSsrcQppZihxPT09cClyZXR1cm4gQy54RApzPUguVk0oW10sdC5zKQpmb3Iocj1xO3I8cDsr
-K3IpaWYoQy54Qi5PKG8scik9PT00Nyl7Qy5ObS5pKHMsQy54Qi5OaihvLHEscikpCnE9cisxfUMuTm0u
-aShzLEMueEIuTmoobyxxLHApKQpyZXR1cm4gUC5BRihzLHQuTil9LApnaFk6ZnVuY3Rpb24oKXtpZih0
-aGlzLmY+PXRoaXMucilyZXR1cm4gQy5DTQpyZXR1cm4gbmV3IFAuR2ooUC5XWCh0aGlzLmd0UCgpKSx0
-LmR3KX0sCmtYOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZCsxCnJldHVybiBzK2EubGVuZ3RoPT09dGhp
-cy5lJiZDLnhCLlFpKHRoaXMuYSxhLHMpfSwKTjk6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5yLHE9
-cy5hCmlmKHI+PXEubGVuZ3RoKXJldHVybiBzCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKHEsMCxyKSxz
-LmIscy5jLHMuZCxzLmUscy5mLHIscy54KX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxu
-LG0sbCxrLGosaT10aGlzLGg9bnVsbAp0LmM5LmEoYikKcz1pLmdGaSgpCnI9cz09PSJmaWxlIgpxPWku
-YwpwPXE+MD9DLnhCLk5qKGkuYSxpLmIrMyxxKToiIgpvPWkuZ3hBKCk/aS5ndHAoaSk6aApxPWkuYwpp
-ZihxPjApbj1DLnhCLk5qKGkuYSxxLGkuZCkKZWxzZSBuPXAubGVuZ3RoIT09MHx8byE9bnVsbHx8cj8i
-IjpoCnE9aS5hCm09Qy54Qi5OaihxLGkuZSxpLmYpCmlmKCFyKWw9biE9bnVsbCYmbS5sZW5ndGghPT0w
-CmVsc2UgbD0hMAppZihsJiYhQy54Qi5uKG0sIi8iKSltPSIvIittCms9UC5sZShoLDAsMCxiKQpsPWku
-cgpqPWw8cS5sZW5ndGg/Qy54Qi55bihxLGwrMSk6aApyZXR1cm4gbmV3IFAuRG4ocyxwLG4sbyxtLGss
-ail9LApaSTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5tUyhQLmhLKGEpKX0sCm1TOmZ1bmN0aW9uKGEp
-e2lmKGEgaW5zdGFuY2VvZiBQLlVmKXJldHVybiB0aGlzLnUxKHRoaXMsYSkKcmV0dXJuIHRoaXMudnMo
-KS5tUyhhKX0sCnUxOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGc9Yi5i
-CmlmKGc+MClyZXR1cm4gYgpzPWIuYwppZihzPjApe3I9YS5iCmlmKHI8PTApcmV0dXJuIGIKaWYoYS5n
-TncoKSlxPWIuZSE9PWIuZgplbHNlIGlmKGEuZ1daKCkpcT0hYi5rWCgiODAiKQplbHNlIHE9IWEuZ1Jl
-KCl8fCFiLmtYKCI0NDMiKQppZihxKXtwPXIrMQpyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihhLmEsMCxw
-KStDLnhCLnluKGIuYSxnKzEpLHIscytwLGIuZCtwLGIuZStwLGIuZitwLGIucitwLGEueCl9ZWxzZSBy
-ZXR1cm4gdGhpcy52cygpLm1TKGIpfW89Yi5lCmc9Yi5mCmlmKG89PT1nKXtzPWIucgppZihnPHMpe3I9
-YS5mCnA9ci1nCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4oYi5hLGcpLGEu
-YixhLmMsYS5kLGEuZSxnK3AscytwLGEueCl9Zz1iLmEKaWYoczxnLmxlbmd0aCl7cj1hLnIKcmV0dXJu
-IG5ldyBQLlVmKEMueEIuTmooYS5hLDAscikrQy54Qi55bihnLHMpLGEuYixhLmMsYS5kLGEuZSxhLmYs
-cysoci1zKSxhLngpfXJldHVybiBhLk45KCl9cz1iLmEKaWYoQy54Qi5RaShzLCIvIixvKSl7cj1hLmUK
-cD1yLW8KcmV0dXJuIG5ldyBQLlVmKEMueEIuTmooYS5hLDAscikrQy54Qi55bihzLG8pLGEuYixhLmMs
-YS5kLHIsZytwLGIucitwLGEueCl9bj1hLmUKbT1hLmYKaWYobj09PW0mJmEuYz4wKXtmb3IoO0MueEIu
-UWkocywiLi4vIixvKTspbys9MwpwPW4tbysxCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLG4p
-KyIvIitDLnhCLnluKHMsbyksYS5iLGEuYyxhLmQsbixnK3AsYi5yK3AsYS54KX1sPWEuYQpmb3Ioaz1u
-O0MueEIuUWkobCwiLi4vIixrKTspays9MwpqPTAKd2hpbGUoITApe2k9byszCmlmKCEoaTw9ZyYmQy54
-Qi5RaShzLCIuLi8iLG8pKSlicmVhazsrK2oKbz1pfWZvcihoPSIiO20+azspey0tbQppZihDLnhCLk8o
-bCxtKT09PTQ3KXtpZihqPT09MCl7aD0iLyIKYnJlYWt9LS1qCmg9Ii8ifX1pZihtPT09ayYmYS5iPD0w
-JiYhQy54Qi5RaShsLCIvIixuKSl7by09aiozCmg9IiJ9cD1tLW8raC5sZW5ndGgKcmV0dXJuIG5ldyBQ
-LlVmKEMueEIuTmoobCwwLG0pK2grQy54Qi55bihzLG8pLGEuYixhLmMsYS5kLG4sZytwLGIucitwLGEu
-eCl9LAp0NDpmdW5jdGlvbigpe3ZhciBzLHIscSxwPXRoaXMKaWYocC5iPj0wJiYhcC5nTncoKSl0aHJv
-dyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBhICIrcC5nRmkoKSsiIFVS
-SSIpKQpzPXAuZgpyPXAuYQppZihzPHIubGVuZ3RoKXtpZihzPHAucil0aHJvdyBILmIoUC5MNCh1Lmkp
-KQp0aHJvdyBILmIoUC5MNCh1LmwpKX1xPSQud1EoKQppZihILm9UKHEpKXM9UC5tbihwKQplbHNle2lm
-KHAuYzxwLmQpSC52KFAuTDQodS5qKSkKcz1DLnhCLk5qKHIscC5lLHMpfXJldHVybiBzfSwKZ2lPOmZ1
-bmN0aW9uKGEpe3ZhciBzPXRoaXMueQpyZXR1cm4gcz09bnVsbD90aGlzLnk9Qy54Qi5naU8odGhpcy5h
-KTpzfSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJldHVybiExCmlmKHRoaXM9PT1iKXJldHVy
-biEwCnJldHVybiB0LmRELmIoYikmJnRoaXMuYT09PWIudygwKX0sCnZzOmZ1bmN0aW9uKCl7dmFyIHM9
-dGhpcyxyPW51bGwscT1zLmdGaSgpLHA9cy5na3UoKSxvPXMuYz4wP3MuZ0pmKHMpOnIsbj1zLmd4QSgp
-P3MuZ3RwKHMpOnIsbT1zLmEsbD1zLmYsaz1DLnhCLk5qKG0scy5lLGwpLGo9cy5yCmw9bDxqP3MuZ3RQ
-KCk6cgpyZXR1cm4gbmV3IFAuRG4ocSxwLG8sbixrLGwsajxtLmxlbmd0aD9zLmdLYSgpOnIpfSwKdzpm
-dW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKJGlpRDoxfQpQLnFlLnByb3RvdHlwZT17fQpXLnFFLnBy
-b3RvdHlwZT17fQpXLkdoLnByb3RvdHlwZT17CnNMVTpmdW5jdGlvbihhLGIpe2EuaHJlZj1ifSwKdzpm
-dW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfSwKJGlHaDoxfQpXLmZZLnByb3RvdHlwZT17Cnc6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX19ClcubkIucHJvdG90eXBlPXskaW5COjF9ClcuQXoucHJv
-dG90eXBlPXskaUF6OjF9ClcuUVAucHJvdG90eXBlPXskaVFQOjF9ClcubngucHJvdG90eXBlPXsKZ0E6
-ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy5vSi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihh
-KXtyZXR1cm4gYS5sZW5ndGh9fQpXLmlkLnByb3RvdHlwZT17fQpXLlFGLnByb3RvdHlwZT17fQpXLk5o
-LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX19ClcuYWUucHJvdG90eXBl
-PXsKRGM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYS5jcmVhdGVIVE1MRG9jdW1lbnQoYil9fQpXLklCLnBy
-b3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj1hLmxlZnQKci50b1N0cmluZwpyPSJSZWN0YW5n
-bGUgKCIrSC5FaihyKSsiLCAiCnM9YS50b3AKcy50b1N0cmluZwpzPXIrSC5FaihzKSsiKSAiCnI9YS53
-aWR0aApyLnRvU3RyaW5nCnI9cytILkVqKHIpKyIgeCAiCnM9YS5oZWlnaHQKcy50b1N0cmluZwpyZXR1
-cm4gcitILkVqKHMpfSwKRE46ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGI9PW51bGwpcmV0dXJuITEK
-aWYodC5xLmIoYikpe3M9YS5sZWZ0CnMudG9TdHJpbmcKcj1iLmxlZnQKci50b1N0cmluZwppZihzPT09
-cil7cz1hLnRvcApzLnRvU3RyaW5nCnI9Yi50b3AKci50b1N0cmluZwppZihzPT09cil7cz1hLndpZHRo
-CnMudG9TdHJpbmcKcj1iLndpZHRoCnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS5oZWlnaHQKcy50b1N0
-cmluZwpyPWIuaGVpZ2h0CnIudG9TdHJpbmcKcj1zPT09cgpzPXJ9ZWxzZSBzPSExfWVsc2Ugcz0hMX1l
-bHNlIHM9ITF9ZWxzZSBzPSExCnJldHVybiBzfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEu
-bGVmdApwLnRvU3RyaW5nCnA9Qy5DRC5naU8ocCkKcz1hLnRvcApzLnRvU3RyaW5nCnM9Qy5DRC5naU8o
-cykKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1DLkNELmdpTyhyKQpxPWEuaGVpZ2h0CnEudG9TdHJpbmcK
-cmV0dXJuIFcuckUocCxzLHIsQy5DRC5naU8ocSkpfSwKJGl0bjoxfQpXLm43LnByb3RvdHlwZT17CmdB
-OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19Clcud3oucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24o
-YSl7cmV0dXJuIHRoaXMuYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC51UChiKQpzPXRo
-aXMuYQppZihiPDB8fGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHRoaXMuJHRpLmMu
-YShzW2JdKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt0aGlzLiR0aS5jLmEoYykKdGhyb3cgSC5iKFAuTDQo
-IkNhbm5vdCBtb2RpZnkgbGlzdCIpKX19ClcuY3YucHJvdG90eXBlPXsKZ1FnOmZ1bmN0aW9uKGEpe3Jl
-dHVybiBuZXcgVy5pNyhhKX0sCmdQOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5JNChhKX0sCnNQOmZ1
-bmN0aW9uKGEsYil7dmFyIHMKdC5RLmEoYikKcz10aGlzLmdQKGEpCnMuVjEoMCkKcy5GVigwLGIpfSwK
-dzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sb2NhbE5hbWV9LApGRjpmdW5jdGlvbihhKXt2YXIgcz0hIWEu
-c2Nyb2xsSW50b1ZpZXdJZk5lZWRlZAppZihzKWEuc2Nyb2xsSW50b1ZpZXdJZk5lZWRlZCgpCmVsc2Ug
-YS5zY3JvbGxJbnRvVmlldygpfSwKbno6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyPXRoaXMucjYo
-YSxjLGQsZSkKc3dpdGNoKGIudG9Mb3dlckNhc2UoKSl7Y2FzZSJiZWZvcmViZWdpbiI6cz1hLnBhcmVu
-dE5vZGUKcy50b1N0cmluZwpKLkVoKHMscixhKQpicmVhawpjYXNlImFmdGVyYmVnaW4iOnM9YS5jaGls
-ZE5vZGVzCnRoaXMubUsoYSxyLHMubGVuZ3RoPjA/c1swXTpudWxsKQpicmVhawpjYXNlImJlZm9yZWVu
-ZCI6YS5hcHBlbmRDaGlsZChyKQpicmVhawpjYXNlImFmdGVyZW5kIjpzPWEucGFyZW50Tm9kZQpzLnRv
-U3RyaW5nCkouRWgocyxyLGEubmV4dFNpYmxpbmcpCmJyZWFrCmRlZmF1bHQ6SC52KFAueFkoIkludmFs
-aWQgcG9zaXRpb24gIitiKSl9fSwKcjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAKaWYoYz09
-bnVsbCl7aWYoZD09bnVsbCl7cz0kLmx0CmlmKHM9PW51bGwpe3M9SC5WTShbXSx0LnYpCnI9bmV3IFcu
-dkQocykKQy5ObS5pKHMsVy5UdyhudWxsKSkKQy5ObS5pKHMsVy5CbCgpKQokLmx0PXIKZD1yfWVsc2Ug
-ZD1zfXM9JC5FVQppZihzPT1udWxsKXtzPW5ldyBXLktvKGQpCiQuRVU9cwpjPXN9ZWxzZXtzLmE9ZApj
-PXN9fWVsc2UgaWYoZCE9bnVsbCl0aHJvdyBILmIoUC54WSgidmFsaWRhdG9yIGNhbiBvbmx5IGJlIHBh
-c3NlZCBpZiB0cmVlU2FuaXRpemVyIGlzIG51bGwiKSkKaWYoJC54bz09bnVsbCl7cz1kb2N1bWVudApy
-PXMuaW1wbGVtZW50YXRpb24Kci50b1N0cmluZwpyPUMubUguRGMociwiIikKJC54bz1yCiQuQk89ci5j
-cmVhdGVSYW5nZSgpCnI9JC54by5jcmVhdGVFbGVtZW50KCJiYXNlIikKdC5jUi5hKHIpCnM9cy5iYXNl
-VVJJCnMudG9TdHJpbmcKci5ocmVmPXMKJC54by5oZWFkLmFwcGVuZENoaWxkKHIpfXM9JC54bwppZihz
-LmJvZHk9PW51bGwpe3I9cy5jcmVhdGVFbGVtZW50KCJib2R5IikKQy5CWi5zR1Mocyx0LnAuYShyKSl9
-cz0kLnhvCmlmKHQucC5iKGEpKXtzPXMuYm9keQpzLnRvU3RyaW5nCnE9c31lbHNle3MudG9TdHJpbmcK
-cT1zLmNyZWF0ZUVsZW1lbnQoYS50YWdOYW1lKQokLnhvLmJvZHkuYXBwZW5kQ2hpbGQocSl9aWYoImNy
-ZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnByb3RvdHlwZSYmIUMuTm0udGco
-Qy5TcSxhLnRhZ05hbWUpKXskLkJPLnNlbGVjdE5vZGVDb250ZW50cyhxKQpzPSQuQk8Kcy50b1N0cmlu
-ZwpwPXMuY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50KGI9PW51bGw/Im51bGwiOmIpfWVsc2V7Si53Zihx
-LGIpCnA9JC54by5jcmVhdGVEb2N1bWVudEZyYWdtZW50KCkKZm9yKDtzPXEuZmlyc3RDaGlsZCxzIT1u
-dWxsOylwLmFwcGVuZENoaWxkKHMpfWlmKHEhPT0kLnhvLmJvZHkpSi5MdChxKQpjLlBuKHApCmRvY3Vt
-ZW50LmFkb3B0Tm9kZShwKQpyZXR1cm4gcH0sCkFIOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gdGhpcy5y
-NihhLGIsYyxudWxsKX0sCnNoZjpmdW5jdGlvbihhLGIpe3RoaXMuWUMoYSxiKX0sCnBrOmZ1bmN0aW9u
-KGEsYixjKXt0aGlzLnNhNChhLG51bGwpCmEuYXBwZW5kQ2hpbGQodGhpcy5yNihhLGIsbnVsbCxjKSl9
-LApZQzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLnBrKGEsYixudWxsKX0sCnNSTjpmdW5jdGlvbihh
-LGIpe2EuaW5uZXJIVE1MPWJ9LApnbnM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEudGFnTmFtZX0sCmdWbDpm
-dW5jdGlvbihhKXtyZXR1cm4gbmV3IFcuZXUoYSwiY2xpY2siLCExLHQuayl9LAokaWN2OjF9ClcuQ3Yu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuaC5iKHQuQS5hKGEpKX0sCiRTOjI1fQpX
-LmVhLnByb3RvdHlwZT17JGllYToxfQpXLkQwLnByb3RvdHlwZT17Ck9uOmZ1bmN0aW9uKGEsYixjLGQp
-e3QuYncuYShjKQppZihjIT1udWxsKXRoaXMudihhLGIsYyxkKX0sCkI6ZnVuY3Rpb24oYSxiLGMpe3Jl
-dHVybiB0aGlzLk9uKGEsYixjLG51bGwpfSwKdjpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gYS5hZGRF
-dmVudExpc3RlbmVyKGIsSC50Uih0LmJ3LmEoYyksMSksZCl9LAokaUQwOjF9ClcuaEgucHJvdG90eXBl
-PXskaWhIOjF9ClcuaDQucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0K
-Vy5ici5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLlZiLnByb3Rv
-dHlwZT17CnNHUzpmdW5jdGlvbihhLGIpe2EuYm9keT1ifX0KVy5mSi5wcm90b3R5cGU9ewplbzpmdW5j
-dGlvbihhLGIsYyxkKXtyZXR1cm4gYS5vcGVuKGIsYywhMCl9LAokaWZKOjF9Clcud2EucHJvdG90eXBl
-PXt9ClcuU2cucHJvdG90eXBlPXskaVNnOjF9ClcudzcucHJvdG90eXBlPXsKZ0RyOmZ1bmN0aW9uKGEp
-e2lmKCJvcmlnaW4iIGluIGEpcmV0dXJuIGEub3JpZ2luCnJldHVybiBILkVqKGEucHJvdG9jb2wpKyIv
-LyIrSC5FaihhLmhvc3QpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfSwKJGl3NzoxfQpX
-LkFqLnByb3RvdHlwZT17JGlBajoxfQpXLmU3LnByb3RvdHlwZT17CmdyODpmdW5jdGlvbihhKXt2YXIg
-cz10aGlzLmEscj1zLmNoaWxkTm9kZXMubGVuZ3RoCmlmKHI9PT0wKXRocm93IEguYihQLlBWKCJObyBl
-bGVtZW50cyIpKQppZihyPjEpdGhyb3cgSC5iKFAuUFYoIk1vcmUgdGhhbiBvbmUgZWxlbWVudCIpKQpz
-PXMuZmlyc3RDaGlsZApzLnRvU3RyaW5nCnJldHVybiBzfSwKRlY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
-LHEscCxvCnQuZWguYShiKQppZihiIGluc3RhbmNlb2YgVy5lNyl7cz1iLmEKcj10aGlzLmEKaWYocyE9
-PXIpZm9yKHE9cy5jaGlsZE5vZGVzLmxlbmd0aCxwPTA7cDxxOysrcCl7bz1zLmZpcnN0Q2hpbGQKby50
-b1N0cmluZwpyLmFwcGVuZENoaWxkKG8pfXJldHVybn1mb3Iocz1iLmdtKGIpLHI9dGhpcy5hO3MuRigp
-OylyLmFwcGVuZENoaWxkKHMuZ2woKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscgp0LkEuYShj
-KQpzPXRoaXMuYQpyPXMuY2hpbGROb2RlcwppZihiPDB8fGI+PXIubGVuZ3RoKXJldHVybiBILk9IKHIs
-YikKcy5yZXBsYWNlQ2hpbGQoYyxyW2JdKX0sCmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5jaGls
-ZE5vZGVzCnJldHVybiBuZXcgVy5XOShzLHMubGVuZ3RoLEgueihzKS5DKCJXOTxHbS5FPiIpKX0sCmdB
-OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2hpbGROb2Rlcy5sZW5ndGh9LApxOmZ1bmN0aW9uKGEs
-Yil7dmFyIHMKSC51UChiKQpzPXRoaXMuYS5jaGlsZE5vZGVzCmlmKGI8MHx8Yj49cy5sZW5ndGgpcmV0
-dXJuIEguT0gocyxiKQpyZXR1cm4gc1tiXX19ClcudUgucHJvdG90eXBlPXsKd2c6ZnVuY3Rpb24oYSl7
-dmFyIHM9YS5wYXJlbnROb2RlCmlmKHMhPW51bGwpcy5yZW1vdmVDaGlsZChhKX0sCkQ0OmZ1bmN0aW9u
-KGEpe3ZhciBzCmZvcig7cz1hLmZpcnN0Q2hpbGQscyE9bnVsbDspYS5yZW1vdmVDaGlsZChzKX0sCnc6
-ZnVuY3Rpb24oYSl7dmFyIHM9YS5ub2RlVmFsdWUKcmV0dXJuIHM9PW51bGw/dGhpcy5VKGEpOnN9LApz
-YTQ6ZnVuY3Rpb24oYSxiKXthLnRleHRDb250ZW50PWJ9LAptSzpmdW5jdGlvbihhLGIsYyl7cmV0dXJu
-IGEuaW5zZXJ0QmVmb3JlKGIsYyl9LAokaXVIOjF9ClcuQkgucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24o
-YSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYj4+PjAhPT1ifHxi
-Pj1hLmxlbmd0aCl0aHJvdyBILmIoUC5DZihiLGEsbnVsbCxudWxsLG51bGwpKQpyZXR1cm4gYVtiXX0s
-Clk1OmZ1bmN0aW9uKGEsYixjKXt0LkEuYShjKQp0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGFzc2lnbiBl
-bGVtZW50IG9mIGltbXV0YWJsZSBMaXN0LiIpKX0sCmd0SDpmdW5jdGlvbihhKXtpZihhLmxlbmd0aD4w
-KXJldHVybiBhWzBdCnRocm93IEguYihQLlBWKCJObyBlbGVtZW50cyIpKX0sCkU6ZnVuY3Rpb24oYSxi
-KXtpZihiPDB8fGI+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsYikKcmV0dXJuIGFbYl19LAokaWJROjEs
-CiRpWGo6MSwKJGljWDoxLAokaXpNOjF9ClcuU04ucHJvdG90eXBlPXt9ClcuZXcucHJvdG90eXBlPXsk
-aWV3OjF9ClcubHAucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy5U
-Yi5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyCmlmKCJjcmVhdGVDb250ZXh0
-dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5wcm90b3R5cGUpcmV0dXJuIHRoaXMuRFcoYSxiLGMs
-ZCkKcz1XLlU5KCI8dGFibGU+IitILkVqKGIpKyI8L3RhYmxlPiIsYyxkKQpyPWRvY3VtZW50LmNyZWF0
-ZURvY3VtZW50RnJhZ21lbnQoKQpyLnRvU3RyaW5nCnMudG9TdHJpbmcKbmV3IFcuZTcocikuRlYoMCxu
-ZXcgVy5lNyhzKSkKcmV0dXJuIHJ9fQpXLkl2LnByb3RvdHlwZT17CnI2OmZ1bmN0aW9uKGEsYixjLGQp
-e3ZhciBzLHIscSxwCmlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5w
-cm90b3R5cGUpcmV0dXJuIHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApyPXMuY3JlYXRlRG9jdW1l
-bnRGcmFnbWVudCgpCnM9Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxlIiksYixjLGQpCnMudG9T
-dHJpbmcKcz1uZXcgVy5lNyhzKQpxPXMuZ3I4KHMpCnEudG9TdHJpbmcKcz1uZXcgVy5lNyhxKQpwPXMu
-Z3I4KHMpCnIudG9TdHJpbmcKcC50b1N0cmluZwpuZXcgVy5lNyhyKS5GVigwLG5ldyBXLmU3KHApKQpy
-ZXR1cm4gcn19ClcuV1AucHJvdG90eXBlPXsKcjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxCmlm
-KCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5wcm90b3R5cGUpcmV0dXJu
-IHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApyPXMuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnM9
-Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxlIiksYixjLGQpCnMudG9TdHJpbmcKcz1uZXcgVy5l
-NyhzKQpxPXMuZ3I4KHMpCnIudG9TdHJpbmcKcS50b1N0cmluZwpuZXcgVy5lNyhyKS5GVigwLG5ldyBX
-LmU3KHEpKQpyZXR1cm4gcn19ClcueVkucHJvdG90eXBlPXsKcGs6ZnVuY3Rpb24oYSxiLGMpe3ZhciBz
-LHIKdGhpcy5zYTQoYSxudWxsKQpzPWEuY29udGVudApzLnRvU3RyaW5nCkouYlQocykKcj10aGlzLnI2
-KGEsYixudWxsLGMpCmEuY29udGVudC5hcHBlbmRDaGlsZChyKX0sCllDOmZ1bmN0aW9uKGEsYil7cmV0
-dXJuIHRoaXMucGsoYSxiLG51bGwpfSwKJGl5WToxfQpXLnc2LnByb3RvdHlwZT17fQpXLks1LnByb3Rv
-dHlwZT17ClBvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1XLlAxKGEub3BlbihiLGMpKQpyZXR1cm4gc30s
-CmdtVzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sb2NhdGlvbn0sCnVzOmZ1bmN0aW9uKGEsYil7cmV0dXJu
-IGEuY29uZmlybShiKX0sCiRpSzU6MSwKJGl2NjoxfQpXLkNtLnByb3RvdHlwZT17JGlDbToxfQpXLkNR
-LnByb3RvdHlwZT17JGlDUToxfQpXLnc0LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj1h
-LmxlZnQKci50b1N0cmluZwpyPSJSZWN0YW5nbGUgKCIrSC5FaihyKSsiLCAiCnM9YS50b3AKcy50b1N0
-cmluZwpzPXIrSC5FaihzKSsiKSAiCnI9YS53aWR0aApyLnRvU3RyaW5nCnI9cytILkVqKHIpKyIgeCAi
-CnM9YS5oZWlnaHQKcy50b1N0cmluZwpyZXR1cm4gcitILkVqKHMpfSwKRE46ZnVuY3Rpb24oYSxiKXt2
-YXIgcyxyCmlmKGI9PW51bGwpcmV0dXJuITEKaWYodC5xLmIoYikpe3M9YS5sZWZ0CnMudG9TdHJpbmcK
-cj1iLmxlZnQKci50b1N0cmluZwppZihzPT09cil7cz1hLnRvcApzLnRvU3RyaW5nCnI9Yi50b3AKci50
-b1N0cmluZwppZihzPT09cil7cz1hLndpZHRoCnMudG9TdHJpbmcKcj1iLndpZHRoCnIudG9TdHJpbmcK
-aWYocz09PXIpe3M9YS5oZWlnaHQKcy50b1N0cmluZwpyPWIuaGVpZ2h0CnIudG9TdHJpbmcKcj1zPT09
-cgpzPXJ9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSExCnJldHVybiBzfSwKZ2lP
-OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEubGVmdApwLnRvU3RyaW5nCnA9Qy5DRC5naU8ocCkKcz1h
-LnRvcApzLnRvU3RyaW5nCnM9Qy5DRC5naU8ocykKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1DLkNELmdp
-TyhyKQpxPWEuaGVpZ2h0CnEudG9TdHJpbmcKcmV0dXJuIFcuckUocCxzLHIsQy5DRC5naU8ocSkpfX0K
-Vy5yaC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9u
-KGEsYil7SC51UChiKQppZihiPj4+MCE9PWJ8fGI+PWEubGVuZ3RoKXRocm93IEguYihQLkNmKGIsYSxu
-dWxsLG51bGwsbnVsbCkpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3QuQS5hKGMpCnRo
-cm93IEguYihQLkw0KCJDYW5ub3QgYXNzaWduIGVsZW1lbnQgb2YgaW1tdXRhYmxlIExpc3QuIikpfSwK
-RTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5ndGgpcmV0dXJuIEguT0goYSxiKQpyZXR1cm4g
-YVtiXX0sCiRpYlE6MSwKJGlYajoxLAokaWNYOjEsCiRpek06MX0KVy5jZi5wcm90b3R5cGU9ewpLOmZ1
-bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbwp0LmVBLmEoYikKZm9yKHM9dGhpcy5ndmMoKSxyPXMubGVu
-Z3RoLHE9dGhpcy5hLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyksKytwKXtv
-PXNbcF0KYi4kMihvLHEuZ2V0QXR0cmlidXRlKG8pKX19LApndmM6ZnVuY3Rpb24oKXt2YXIgcyxyLHEs
-cCxvLG4sbT10aGlzLmEuYXR0cmlidXRlcwptLnRvU3RyaW5nCnM9SC5WTShbXSx0LnMpCmZvcihyPW0u
-bGVuZ3RoLHE9dC5oOSxwPTA7cDxyOysrcCl7aWYocD49bS5sZW5ndGgpcmV0dXJuIEguT0gobSxwKQpv
-PXEuYShtW3BdKQppZihvLm5hbWVzcGFjZVVSST09bnVsbCl7bj1vLm5hbWUKbi50b1N0cmluZwpDLk5t
-LmkocyxuKX19cmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3Ro
-PT09MH19ClcuaTcucHJvdG90eXBlPXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vVCh0aGlzLmEuaGFz
-QXR0cmlidXRlKGEpKQpyZXR1cm4gc30sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5hLmdldEF0
-dHJpYnV0ZShILmgoYikpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuYS5zZXRBdHRyaWJ1dGUoYixj
-KX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH19ClcuU3kucHJvdG90eXBl
-PXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vVCh0aGlzLmEuYS5oYXNBdHRyaWJ1dGUoImRhdGEtIit0
-aGlzLk9VKGEpKSkKcmV0dXJuIHN9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS5hLmdldEF0
-dHJpYnV0ZSgiZGF0YS0iK3RoaXMuT1UoSC5oKGIpKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5h
-LmEuc2V0QXR0cmlidXRlKCJkYXRhLSIrdGhpcy5PVShiKSxjKX0sCks6ZnVuY3Rpb24oYSxiKXt0aGlz
-LmEuSygwLG5ldyBXLktTKHRoaXMsdC5lQS5hKGIpKSl9LApndmM6ZnVuY3Rpb24oKXt2YXIgcz1ILlZN
-KFtdLHQucykKdGhpcy5hLksoMCxuZXcgVy5BMyh0aGlzLHMpKQpyZXR1cm4gc30sCmdBOmZ1bmN0aW9u
-KGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5n
-dmMoKS5sZW5ndGg9PT0wfSwKeHE6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUguVk0oYS5zcGxpdCgiLSIp
-LHQucykKZm9yKHM9MTtzPHEubGVuZ3RoOysrcyl7cj1xW3NdCmlmKHIubGVuZ3RoPjApQy5ObS5ZNShx
-LHMsclswXS50b1VwcGVyQ2FzZSgpK0ouS1YociwxKSl9cmV0dXJuIEMuTm0uayhxLCIiKX0sCk9VOmZ1
-bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8KZm9yKHM9YS5sZW5ndGgscj0wLHE9IiI7cjxzOysrcil7cD1h
-W3JdCm89cC50b0xvd2VyQ2FzZSgpCnE9KHAhPT1vJiZyPjA/cSsiLSI6cSkrb31yZXR1cm4gcS5jaGFy
-Q29kZUF0KDApPT0wP3E6cX19ClcuS1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXtpZihKLnJZ
-KGEpLm4oYSwiZGF0YS0iKSl0aGlzLmIuJDIodGhpcy5hLnhxKEMueEIueW4oYSw1KSksYil9LAokUzox
-NX0KVy5BMy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe2lmKEouclkoYSkubihhLCJkYXRhLSIp
-KUMuTm0uaSh0aGlzLmIsdGhpcy5hLnhxKEMueEIueW4oYSw1KSkpfSwKJFM6MTV9ClcuSTQucHJvdG90
-eXBlPXsKRDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89UC5Mcyh0Lk4pCmZvcihzPXRoaXMuYS5jbGFz
-c05hbWUuc3BsaXQoIiAiKSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPUouVDAoc1txXSkKaWYocC5s
-ZW5ndGghPT0wKW8uaSgwLHApfXJldHVybiBvfSwKWDpmdW5jdGlvbihhKXt0aGlzLmEuY2xhc3NOYW1l
-PXQuQy5hKGEpLmsoMCwiICIpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3Qu
-bGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2xhc3NMaXN0Lmxlbmd0aD09PTB9
-LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3RoIT09MH0sClYxOmZ1
-bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05hbWU9IiJ9LAp0ZzpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMu
-YS5jbGFzc0xpc3QuY29udGFpbnMoYikKcmV0dXJuIHN9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpI
-LmgoYikKcz10aGlzLmEuY2xhc3NMaXN0CnI9cy5jb250YWlucyhiKQpzLmFkZChiKQpyZXR1cm4hcn0s
-ClI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPXRoaXMuYS5j
-bGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMucmVtb3ZlKGIpCnE9cn1lbHNlIHE9ITEKcmV0dXJuIHF9
-LApGVjpmdW5jdGlvbihhLGIpe1cuVE4odGhpcy5hLHQuUS5hKGIpKX19ClcuRmsucHJvdG90eXBlPXt9
-ClcuUk8ucHJvdG90eXBlPXt9ClcuZXUucHJvdG90eXBlPXt9ClcueEMucHJvdG90eXBlPXt9Clcudk4u
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMSh0LkIuYShhKSl9LAokUzoy
-N30KVy5KUS5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhKXt2YXIgcwppZigkLm9yLmE9PT0wKXtmb3Io
-cz0wO3M8MjYyOysrcykkLm9yLlk1KDAsQy5jbVtzXSxXLnBTKCkpCmZvcihzPTA7czwxMjsrK3MpJC5v
-ci5ZNSgwLEMuQklbc10sVy5WNCgpKX19LAppMDpmdW5jdGlvbihhKXtyZXR1cm4gJC5BTigpLnRnKDAs
-Vy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9JC5vci5xKDAsSC5FaihXLnJTKGEpKSsi
-OjoiK2IpCmlmKHM9PW51bGwpcz0kLm9yLnEoMCwiKjo6IitiKQppZihzPT1udWxsKXJldHVybiExCnJl
-dHVybiBILnk4KHMuJDQoYSxiLGMsdGhpcykpfSwKJGlrRjoxfQpXLkdtLnByb3RvdHlwZT17CmdtOmZ1
-bmN0aW9uKGEpe3JldHVybiBuZXcgVy5XOShhLHRoaXMuZ0EoYSksSC56KGEpLkMoIlc5PEdtLkU+Iikp
-fX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1cm4gQy5ObS5Wcih0aGlzLmEsbmV3
-IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBDLk5tLlZyKHRoaXMuYSxuZXcgVy5F
-ZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0
-LkUuYShhKS5pMCh0aGlzLmEpfSwKJFM6MTZ9ClcuRWcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7
-cmV0dXJuIHQuRS5hKGEpLkViKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjE2fQpXLm02LnByb3Rv
-dHlwZT17CkNZOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQp0aGlzLmEuRlYoMCxjKQpzPWIuZXYo
-MCxuZXcgVy5FbygpKQpyPWIuZXYoMCxuZXcgVy5XaygpKQp0aGlzLmIuRlYoMCxzKQpxPXRoaXMuYwpx
-LkZWKDAsQy54RCkKcS5GVigwLHIpfSwKaTA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS50ZygwLFcu
-clMoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMscj1XLnJTKGEpLHE9cy5jCmlmKHEu
-dGcoMCxILkVqKHIpKyI6OiIrYikpcmV0dXJuIHMuZC5EdChjKQplbHNlIGlmKHEudGcoMCwiKjo6Iiti
-KSlyZXR1cm4gcy5kLkR0KGMpCmVsc2V7cT1zLmIKaWYocS50ZygwLEguRWoocikrIjo6IitiKSlyZXR1
-cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCxILkVqKHIp
-KyI6OioiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6KiIpKXJldHVybiEwfXJldHVybiExfSwK
-JGlrRjoxfQpXLkVvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiFDLk5tLnRnKEMuQkks
-SC5oKGEpKX0sCiRTOjZ9ClcuV2sucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEMuTm0u
-dGcoQy5CSSxILmgoYSkpfSwKJFM6Nn0KVy5jdC5wcm90b3R5cGU9ewpFYjpmdW5jdGlvbihhLGIsYyl7
-aWYodGhpcy5qRihhLGIsYykpcmV0dXJuITAKaWYoYj09PSJ0ZW1wbGF0ZSImJmM9PT0iIilyZXR1cm4h
-MAppZihhLmdldEF0dHJpYnV0ZSgidGVtcGxhdGUiKT09PSIiKXJldHVybiB0aGlzLmUudGcoMCxiKQpy
-ZXR1cm4hMX19ClcuSUEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIlRFTVBMQVRFOjoi
-K0guRWooSC5oKGEpKX0sCiRTOjV9ClcuT3cucHJvdG90eXBlPXsKaTA6ZnVuY3Rpb24oYSl7dmFyIHMK
-aWYodC5ldy5iKGEpKXJldHVybiExCnM9dC5nNy5iKGEpCmlmKHMmJlcuclMoYSk9PT0iZm9yZWlnbk9i
-amVjdCIpcmV0dXJuITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0sCkViOmZ1bmN0aW9uKGEsYixjKXtp
-ZihiPT09ImlzInx8Qy54Qi5uKGIsIm9uIikpcmV0dXJuITEKcmV0dXJuIHRoaXMuaTAoYSl9LAokaWtG
-OjF9ClcuVzkucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLmMrMSxxPXMuYgpp
-ZihyPHEpe3Muc3AoSi54OShzLmEscikpCnMuYz1yCnJldHVybiEwfXMuc3AobnVsbCkKcy5jPXEKcmV0
-dXJuITF9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9LApzcDpmdW5jdGlvbihhKXt0aGlzLmQ9
-dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpXLmRXLnByb3RvdHlwZT17JGlEMDoxLCRpdjY6
-MX0KVy5tay5wcm90b3R5cGU9eyRpeTA6MX0KVy5Lby5wcm90b3R5cGU9ewpQbjpmdW5jdGlvbihhKXt2
-YXIgcz10aGlzLHI9bmV3IFcuZm0ocykKcy5iPSExCnIuJDIoYSxudWxsKQpmb3IoO3MuYjspe3MuYj0h
-MQpyLiQyKGEsbnVsbCl9fSwKRVA6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmI9ITAKaWYoYiE9bnVs
-bD9iIT09YS5wYXJlbnROb2RlOnMpSi5MdChhKQplbHNlIGIucmVtb3ZlQ2hpbGQoYSl9LApJNDpmdW5j
-dGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj0hMCxtPW51bGwsbD1udWxsCnRyeXttPUouaWcoYSkKbD1t
-LmEuZ2V0QXR0cmlidXRlKCJpcyIpCnQuaC5hKGEpCnM9ZnVuY3Rpb24oYyl7aWYoIShjLmF0dHJpYnV0
-ZXMgaW5zdGFuY2VvZiBOYW1lZE5vZGVNYXApKXJldHVybiB0cnVlCmlmKGMuaWQ9PSdsYXN0Q2hpbGQn
-fHxjLm5hbWU9PSdsYXN0Q2hpbGQnfHxjLmlkPT0ncHJldmlvdXNTaWJsaW5nJ3x8Yy5uYW1lPT0ncHJl
-dmlvdXNTaWJsaW5nJ3x8Yy5pZD09J2NoaWxkcmVuJ3x8Yy5uYW1lPT0nY2hpbGRyZW4nKXJldHVybiB0
-cnVlCnZhciBrPWMuY2hpbGROb2RlcwppZihjLmxhc3RDaGlsZCYmYy5sYXN0Q2hpbGQhPT1rW2subGVu
-Z3RoLTFdKXJldHVybiB0cnVlCmlmKGMuY2hpbGRyZW4paWYoIShjLmNoaWxkcmVuIGluc3RhbmNlb2Yg
-SFRNTENvbGxlY3Rpb258fGMuY2hpbGRyZW4gaW5zdGFuY2VvZiBOb2RlTGlzdCkpcmV0dXJuIHRydWUK
-dmFyIGo9MAppZihjLmNoaWxkcmVuKWo9Yy5jaGlsZHJlbi5sZW5ndGgKZm9yKHZhciBpPTA7aTxqO2kr
-Kyl7dmFyIGg9Yy5jaGlsZHJlbltpXQppZihoLmlkPT0nYXR0cmlidXRlcyd8fGgubmFtZT09J2F0dHJp
-YnV0ZXMnfHxoLmlkPT0nbGFzdENoaWxkJ3x8aC5uYW1lPT0nbGFzdENoaWxkJ3x8aC5pZD09J3ByZXZp
-b3VzU2libGluZyd8fGgubmFtZT09J3ByZXZpb3VzU2libGluZyd8fGguaWQ9PSdjaGlsZHJlbid8fGgu
-bmFtZT09J2NoaWxkcmVuJylyZXR1cm4gdHJ1ZX1yZXR1cm4gZmFsc2V9KGEpCm49SC5vVChzKT8hMDoh
-KGEuYXR0cmlidXRlcyBpbnN0YW5jZW9mIE5hbWVkTm9kZU1hcCl9Y2F0Y2gocCl7SC5SdShwKX1yPSJl
-bGVtZW50IHVucHJpbnRhYmxlIgp0cnl7cj1KLmooYSl9Y2F0Y2gocCl7SC5SdShwKX10cnl7cT1XLnJT
-KGEpCnRoaXMua1IodC5oLmEoYSksYixuLHIscSx0LmYuYShtKSxILmsobCkpfWNhdGNoKHApe2lmKEgu
-UnUocCkgaW5zdGFuY2VvZiBQLnUpdGhyb3cgcAplbHNle3RoaXMuRVAoYSxiKQp3aW5kb3cKbz0iUmVt
-b3ZpbmcgY29ycnVwdGVkIGVsZW1lbnQgIitILkVqKHIpCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZp
-bmVkIil3aW5kb3cuY29uc29sZS53YXJuKG8pfX19LAprUjpmdW5jdGlvbihhLGIsYyxkLGUsZixnKXt2
-YXIgcyxyLHEscCxvLG4sbT10aGlzCmlmKGMpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZWxl
-bWVudCBkdWUgdG8gY29ycnVwdGVkIGF0dHJpYnV0ZXMgb24gPCIrZCsiPiIKaWYodHlwZW9mIGNvbnNv
-bGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0dXJufWlmKCFtLmEuaTAoYSkp
-e20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBlbGVtZW50IDwiK0guRWooZSkr
-Ij4gZnJvbSAiK0guRWooYikKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25z
-b2xlLndhcm4ocykKcmV0dXJufWlmKGchPW51bGwpaWYoIW0uYS5FYihhLCJpcyIsZykpe20uRVAoYSxi
-KQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCB0eXBlIGV4dGVuc2lvbiA8IitILkVqKGUpKycg
-aXM9IicrZysnIj4nCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53
-YXJuKHMpCnJldHVybn1zPWYuZ3ZjKCkKcj1ILlZNKHMuc2xpY2UoMCksSC50NihzKSkKZm9yKHE9Zi5n
-dmMoKS5sZW5ndGgtMSxzPWYuYTtxPj0wOy0tcSl7aWYocT49ci5sZW5ndGgpcmV0dXJuIEguT0gocixx
-KQpwPXJbcV0Kbz1tLmEKbj1KLmNIKHApCkguaChwKQppZighby5FYihhLG4scy5nZXRBdHRyaWJ1dGUo
-cCkpKXt3aW5kb3cKbz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBhdHRyaWJ1dGUgPCIrSC5FaihlKSsiICIr
-cCsnPSInK0guRWoocy5nZXRBdHRyaWJ1dGUocCkpKyciPicKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRl
-ZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4obykKcy5yZW1vdmVBdHRyaWJ1dGUocCl9fWlmKHQuYVcu
-YihhKSl7cz1hLmNvbnRlbnQKcy50b1N0cmluZwptLlBuKHMpfX0sCiRpb246MX0KVy5mbS5wcm90b3R5
-cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMuYQpzd2l0Y2goYS5ub2Rl
-VHlwZSl7Y2FzZSAxOm0uSTQoYSxiKQpicmVhawpjYXNlIDg6Y2FzZSAxMTpjYXNlIDM6Y2FzZSA0OmJy
-ZWFrCmRlZmF1bHQ6bS5FUChhLGIpfXM9YS5sYXN0Q2hpbGQKZm9yKHE9dC5BO251bGwhPXM7KXtyPW51
-bGwKdHJ5e3I9cy5wcmV2aW91c1NpYmxpbmcKaWYociE9bnVsbCl7cD1yLm5leHRTaWJsaW5nCm89cwpv
-PXA9PW51bGw/byE9bnVsbDpwIT09bwpwPW99ZWxzZSBwPSExCmlmKHApe3A9UC5QVigiQ29ycnVwdCBI
-VE1MIikKdGhyb3cgSC5iKHApfX1jYXRjaChuKXtILlJ1KG4pCnA9cS5hKHMpCm0uYj0hMApvPXAucGFy
-ZW50Tm9kZQpvPWE9PW51bGw/byE9bnVsbDphIT09bwppZihvKXtvPXAucGFyZW50Tm9kZQppZihvIT1u
-dWxsKW8ucmVtb3ZlQ2hpbGQocCl9ZWxzZSBhLnJlbW92ZUNoaWxkKHApCnM9bnVsbApyPWEubGFzdENo
-aWxkfWlmKHMhPW51bGwpdGhpcy4kMihzLGEpCnM9cn19LAokUzozMH0KVy5MZS5wcm90b3R5cGU9e30K
-Vy5LNy5wcm90b3R5cGU9e30KVy5yQi5wcm90b3R5cGU9e30KVy5YVy5wcm90b3R5cGU9e30KVy5vYS5w
-cm90b3R5cGU9e30KUC5pSi5wcm90b3R5cGU9ewpWSDpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuYSxx
-PXIubGVuZ3RoCmZvcihzPTA7czxxOysrcylpZihyW3NdPT09YSlyZXR1cm4gcwpDLk5tLmkocixhKQpD
-Lk5tLmkodGhpcy5iLG51bGwpCnJldHVybiBxfSwKUHY6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9dGhp
-cyxvPXt9CmlmKGE9PW51bGwpcmV0dXJuIGEKaWYoSC5sKGEpKXJldHVybiBhCmlmKHR5cGVvZiBhPT0i
-bnVtYmVyIilyZXR1cm4gYQppZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIGEKaWYoYSBpbnN0YW5j
-ZW9mIFAuaVApcmV0dXJuIG5ldyBEYXRlKGEuYSkKaWYodC5mdi5iKGEpKXRocm93IEguYihQLlNZKCJz
-dHJ1Y3R1cmVkIGNsb25lIG9mIFJlZ0V4cCIpKQppZih0LmM4LmIoYSkpcmV0dXJuIGEKaWYodC53LmIo
-YSkpcmV0dXJuIGEKaWYodC5JLmIoYSkpcmV0dXJuIGEKcz10LmRFLmIoYSl8fCExCmlmKHMpcmV0dXJu
-IGEKaWYodC5mLmIoYSkpe3I9cC5WSChhKQpzPXAuYgppZihyPj1zLmxlbmd0aClyZXR1cm4gSC5PSChz
-LHIpCnE9by5hPXNbcl0KaWYocSE9bnVsbClyZXR1cm4gcQpxPXt9Cm8uYT1xCkMuTm0uWTUocyxyLHEp
-CmEuSygwLG5ldyBQLmpnKG8scCkpCnJldHVybiBvLmF9aWYodC5qLmIoYSkpe3I9cC5WSChhKQpvPXAu
-YgppZihyPj1vLmxlbmd0aClyZXR1cm4gSC5PSChvLHIpCnE9b1tyXQppZihxIT1udWxsKXJldHVybiBx
-CnJldHVybiBwLmVrKGEscil9aWYodC5lSC5iKGEpKXtyPXAuVkgoYSkKcz1wLmIKaWYocj49cy5sZW5n
-dGgpcmV0dXJuIEguT0gocyxyKQpxPW8uYj1zW3JdCmlmKHEhPW51bGwpcmV0dXJuIHEKcT17fQpvLmI9
-cQpDLk5tLlk1KHMscixxKQpwLmltKGEsbmV3IFAuVGEobyxwKSkKcmV0dXJuIG8uYn10aHJvdyBILmIo
-UC5TWSgic3RydWN0dXJlZCBjbG9uZSBvZiBvdGhlciB0eXBlIikpfSwKZWs6ZnVuY3Rpb24oYSxiKXt2
-YXIgcyxyPUouVTYoYSkscT1yLmdBKGEpLHA9bmV3IEFycmF5KHEpCkMuTm0uWTUodGhpcy5iLGIscCkK
-Zm9yKHM9MDtzPHE7KytzKUMuTm0uWTUocCxzLHRoaXMuUHYoci5xKGEscykpKQpyZXR1cm4gcH19ClAu
-amcucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuYVthXT10aGlzLmIuUHYoYil9LAok
-UzozMX0KUC5UYS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS5iW2FdPXRoaXMuYi5Q
-dihiKX0sCiRTOjE3fQpQLkJmLnByb3RvdHlwZT17CmltOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAK
-dC5iOC5hKGIpCmZvcihzPU9iamVjdC5rZXlzKGEpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Epe3A9c1tx
-XQpiLiQyKHAsYVtwXSl9fX0KUC5Bcy5wcm90b3R5cGU9ewpWOmZ1bmN0aW9uKGEpe3ZhciBzCkguaChh
-KQpzPSQuaEcoKS5iCmlmKHR5cGVvZiBhIT0ic3RyaW5nIilILnYoSC50TChhKSkKaWYocy50ZXN0KGEp
-KXJldHVybiBhCnRocm93IEguYihQLkwzKGEsInZhbHVlIiwiTm90IGEgdmFsaWQgY2xhc3MgdG9rZW4i
-KSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5rKDAsIiAiKX0sCmdtOmZ1bmN0aW9uKGEp
-e3ZhciBzPXRoaXMuRCgpCnJldHVybiBQLnJqKHMscy5yLEguTGgocykuYyl9LApnbDA6ZnVuY3Rpb24o
-YSl7cmV0dXJuIHRoaXMuRCgpLmE9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5h
-IT09MH0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hfSwKdGc6ZnVuY3Rpb24oYSxiKXt0
-aGlzLlYoYikKcmV0dXJuIHRoaXMuRCgpLnRnKDAsYil9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC5o
-KGIpCnRoaXMuVihiKQpzPXRoaXMuT1MobmV3IFAuR0UoYikpCnJldHVybiBILnk4KHM9PW51bGw/ITE6
-cyl9LApSOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZih0eXBlb2YgYiE9InN0cmluZyIpcmV0dXJuITEK
-dGhpcy5WKGIpCnM9dGhpcy5EKCkKcj1zLlIoMCxiKQp0aGlzLlgocykKcmV0dXJuIHJ9LApGVjpmdW5j
-dGlvbihhLGIpe3RoaXMuT1MobmV3IFAuTjcodGhpcyx0LlEuYShiKSkpfSwKZVI6ZnVuY3Rpb24oYSxi
-KXt2YXIgcz10aGlzLkQoKQpyZXR1cm4gSC5iSyhzLGIsSC5MaChzKS5DKCJsZi5FIikpfSwKRTpmdW5j
-dGlvbihhLGIpe3JldHVybiB0aGlzLkQoKS5FKDAsYil9LApWMTpmdW5jdGlvbihhKXt0aGlzLk9TKG5l
-dyBQLnVRKCkpfSwKT1M6ZnVuY3Rpb24oYSl7dmFyIHMscgp0LmJVLmEoYSkKcz10aGlzLkQoKQpyPWEu
-JDEocykKdGhpcy5YKHMpCnJldHVybiByfX0KUC5HRS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXty
-ZXR1cm4gdC5DLmEoYSkuaSgwLHRoaXMuYSl9LAokUzozM30KUC5ONy5wcm90b3R5cGU9ewokMTpmdW5j
-dGlvbihhKXt2YXIgcz10aGlzLmIscj1ILnQ2KHMpCnJldHVybiB0LkMuYShhKS5GVigwLG5ldyBILmxK
-KHMsci5DKCJxVSgxKSIpLmEodGhpcy5hLmd1TSgpKSxyLkMoImxKPDEscVU+IikpKX0sCiRTOjE4fQpQ
-LnVRLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuQy5hKGEpCmlmKGEuYT4wKXthLmI9YS5jPWEu
-ZD1hLmU9YS5mPW51bGwKYS5hPTAKYS5TKCl9cmV0dXJuIG51bGx9LAokUzoxOH0KUC5oRi5wcm90b3R5
-cGU9eyRpaEY6MX0KUC5QQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0LlkuYShhKQpz
-PWZ1bmN0aW9uKGIsYyxkKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4gYihjLGQsdGhpcyxBcnJheS5w
-cm90b3R5cGUuc2xpY2UuYXBwbHkoYXJndW1lbnRzKSl9fShQLlI0LGEsITEpClAuRG0ocywkLncoKSxh
-KQpyZXR1cm4gc30sCiRTOjR9ClAubXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIG5l
-dyB0aGlzLmEoYSl9LAokUzo0fQpQLlFTLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBu
-ZXcgUC5yNyhhKX0sCiRTOjM1fQpQLm5wLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBu
-ZXcgUC5UeihhLHQuYW0pfSwKJFM6NTR9ClAuVXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0
-dXJuIG5ldyBQLkU0KGEpfSwKJFM6Mzd9ClAuRTQucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe2lm
-KHR5cGVvZiBiIT0ic3RyaW5nIiYmdHlwZW9mIGIhPSJudW1iZXIiKXRocm93IEguYihQLnhZKCJwcm9w
-ZXJ0eSBpcyBub3QgYSBTdHJpbmcgb3IgbnVtIikpCnJldHVybiBQLmRVKHRoaXMuYVtiXSl9LApZNTpm
-dW5jdGlvbihhLGIsYyl7aWYodHlwZW9mIGIhPSJzdHJpbmciJiZ0eXBlb2YgYiE9Im51bWJlciIpdGhy
-b3cgSC5iKFAueFkoInByb3BlcnR5IGlzIG5vdCBhIFN0cmluZyBvciBudW0iKSkKdGhpcy5hW2JdPVAu
-d1koYyl9LApETjpmdW5jdGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKcmV0dXJuIGIgaW5zdGFu
-Y2VvZiBQLkU0JiZ0aGlzLmE9PT1iLmF9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIKdHJ5e3M9U3RyaW5n
-KHRoaXMuYSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKQpzPXRoaXMueGIoMCkKcmV0dXJuIHN9fSwK
-Vjc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuYQppZihiPT1udWxsKXM9bnVsbAplbHNle3M9SC50
-NihiKQpzPVAuQ0gobmV3IEgubEooYixzLkMoIkAoMSkiKS5hKFAuaUcoKSkscy5DKCJsSjwxLEA+Iikp
-LCEwLHQueil9cmV0dXJuIFAuZFUoclthXS5hcHBseShyLHMpKX0sCmdpTzpmdW5jdGlvbihhKXtyZXR1
-cm4gMH19ClAucjcucHJvdG90eXBlPXt9ClAuVHoucHJvdG90eXBlPXsKY1A6ZnVuY3Rpb24oYSl7dmFy
-IHM9dGhpcyxyPWE8MHx8YT49cy5nQShzKQppZihyKXRocm93IEguYihQLlRFKGEsMCxzLmdBKHMpLG51
-bGwsbnVsbCkpfSwKcTpmdW5jdGlvbihhLGIpe2lmKEgub2soYikpdGhpcy5jUChiKQpyZXR1cm4gdGhp
-cy4kdGkuYy5hKHRoaXMuVXIoMCxiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5jUChiKQp0aGlz
-LmJoKDAsYixjKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5sZW5ndGgKaWYodHlwZW9mIHM9
-PT0ibnVtYmVyIiYmcz4+PjA9PT1zKXJldHVybiBzCnRocm93IEguYihQLlBWKCJCYWQgSnNBcnJheSBs
-ZW5ndGgiKSl9LAokaWJROjEsCiRpY1g6MSwKJGl6TToxfQpQLmNvLnByb3RvdHlwZT17Clk1OmZ1bmN0
-aW9uKGEsYixjKXtyZXR1cm4gdGhpcy5lNCgwLGIsYyl9fQpQLm5kLnByb3RvdHlwZT17JGluZDoxfQpQ
-LktlLnByb3RvdHlwZT17CkQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMuYS5nZXRBdHRyaWJ1
-dGUoImNsYXNzIiksbj1QLkxzKHQuTikKaWYobz09bnVsbClyZXR1cm4gbgpmb3Iocz1vLnNwbGl0KCIg
-Iikscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1KLlQwKHNbcV0pCmlmKHAubGVuZ3RoIT09MCluLmko
-MCxwKX1yZXR1cm4gbn0sClg6ZnVuY3Rpb24oYSl7dGhpcy5hLnNldEF0dHJpYnV0ZSgiY2xhc3MiLGEu
-aygwLCIgIikpfX0KUC5oaS5wcm90b3R5cGU9ewpnUDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuS2Uo
-YSl9LApzaGY6ZnVuY3Rpb24oYSxiKXt0aGlzLllDKGEsYil9LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2
-YXIgcyxyLHEscCxvLG4KaWYoZD09bnVsbCl7cz1ILlZNKFtdLHQudikKZD1uZXcgVy52RChzKQpDLk5t
-LmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJsKCkpCkMuTm0uaShzLG5ldyBXLk93KCkpfWM9bmV3
-IFcuS28oZCkKcj0nPHN2ZyB2ZXJzaW9uPSIxLjEiPicrSC5FaihiKSsiPC9zdmc+IgpzPWRvY3VtZW50
-CnE9cy5ib2R5CnEudG9TdHJpbmcKcD1DLlJZLkFIKHEscixjKQpvPXMuY3JlYXRlRG9jdW1lbnRGcmFn
-bWVudCgpCnAudG9TdHJpbmcKcz1uZXcgVy5lNyhwKQpuPXMuZ3I4KHMpCmZvcig7cz1uLmZpcnN0Q2hp
-bGQscyE9bnVsbDspby5hcHBlbmRDaGlsZChzKQpyZXR1cm4gb30sCm56OmZ1bmN0aW9uKGEsYixjLGQs
-ZSl7dGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBpbnZva2UgaW5zZXJ0QWRqYWNlbnRIdG1sIG9uIFNWRy4i
-KSl9LApnVmw6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLmV1KGEsImNsaWNrIiwhMSx0LmspfSwKJGlo
-aToxfQpNLkg3LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYn19ClUuTEwucHJv
-dG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbIm5vZGVJZCIsdGhpcy5iLCJraW5kIix0
-aGlzLmEuYV0sdC5YLHQuXyl9fQpVLk1ELnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0
-LmZFLmEoYSkuYT09PXRoaXMuYS5xKDAsImtpbmQiKX0sCiRTOjM4fQpVLmQyLnByb3RvdHlwZT17Ckx0
-OmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzLG49dC5YLG09dC5fLGw9UC5GbChuLG0pLGs9by5h
-CmlmKGshPW51bGwpe3M9SC5WTShbXSx0LkcpCmZvcihyPWsubGVuZ3RoLHE9MDtxPGsubGVuZ3RoO2su
-bGVuZ3RoPT09cnx8KDAsSC5saykoayksKytxKXtwPWtbcV0Kcy5wdXNoKFAuRUYoWyJkZXNjcmlwdGlv
-biIscC5hLCJocmVmIixwLmJdLG4sbSkpfWwuWTUoMCwiZWRpdHMiLHMpfWwuWTUoMCwiZXhwbGFuYXRp
-b24iLG8uYikKbC5ZNSgwLCJsaW5lIixvLmMpCmwuWTUoMCwiZGlzcGxheVBhdGgiLG8uZCkKbC5ZNSgw
-LCJ1cmlQYXRoIixvLmUpCm49by5mCmlmKG4hPW51bGwpe209SC5WTShbXSx0LkcpCmZvcihrPW4ubGVu
-Z3RoLHE9MDtxPG4ubGVuZ3RoO24ubGVuZ3RoPT09a3x8KDAsSC5saykobiksKytxKW0ucHVzaChuW3Fd
-Lkx0KCkpCmwuWTUoMCwidHJhY2VzIixtKX1yZXR1cm4gbH19ClUuU2UucHJvdG90eXBlPXsKTHQ6ZnVu
-Y3Rpb24oKXtyZXR1cm4gUC5FRihbImRlc2NyaXB0aW9uIix0aGlzLmEsImhyZWYiLHRoaXMuYl0sdC5Y
-LHQuXyl9fQpVLk1sLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJuIFAuRUYoWyJocmVmIix0
-aGlzLmEsImxpbmUiLHRoaXMuYiwicGF0aCIsdGhpcy5jXSx0LlgsdC5fKX19ClUueUQucHJvdG90eXBl
-PXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD1ILlZNKFtdLHQuRykKZm9yKHM9dGhpcy5iLHI9cy5s
-ZW5ndGgscT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3EpcC5wdXNoKHNb
-cV0uTHQoKSkKcmV0dXJuIFAuRUYoWyJkZXNjcmlwdGlvbiIsdGhpcy5hLCJlbnRyaWVzIixwXSx0Llgs
-dC5fKX19ClUud2IucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD10aGlzLG89UC5G
-bCh0LlgsdC5fKQpvLlk1KDAsImRlc2NyaXB0aW9uIixwLmEpCnM9cC5iCmlmKHMhPW51bGwpby5ZNSgw
-LCJmdW5jdGlvbiIscykKcz1wLmMKaWYocyE9bnVsbClvLlk1KDAsImxpbmsiLHMuTHQoKSkKcz1wLmQK
-aWYocy5sZW5ndGghPT0wKXtyPUgudDYocykKcT1yLkMoImxKPDEsWjA8cVUqLE1oKj4qPiIpCm8uWTUo
-MCwiaGludEFjdGlvbnMiLFAuWTEobmV3IEgubEoocyxyLkMoIlowPHFVKixNaCo+KigxKSIpLmEobmV3
-IFUuYjAoKSkscSksITAscS5DKCJhTC5FIikpKX1yZXR1cm4gb319ClUuYU4ucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7cmV0dXJuIFUubnoodC50LmEoYSkpfSwKJFM6Mzl9ClUuYjAucHJvdG90eXBlPXsK
-JDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuYVguYShhKS5MdCgpfSwKJFM6NDB9CkIuajgucHJvdG90eXBl
-PXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbImxpbmUiLHRoaXMuYSwiZXhwbGFuYXRpb24iLHRo
-aXMuYiwib2Zmc2V0Iix0aGlzLmNdLHQuWCx0Ll8pfX0KQi5xcC5wcm90b3R5cGU9ewpMdDpmdW5jdGlv
-bigpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcyxrPXQuWCxqPVAuRmwoayx0LmRwKQpmb3Iocz1sLmQs
-cz1zLmdQdShzKSxzPXMuZ20ocykscj10Ll8scT10Lkc7cy5GKCk7KXtwPXMuZ2woKQpvPXAuYQpuPUgu
-Vk0oW10scSkKZm9yKHA9Si5JVChwLmIpO3AuRigpOyl7bT1wLmdsKCkKbi5wdXNoKFAuRUYoWyJsaW5l
-IixtLmEsImV4cGxhbmF0aW9uIixtLmIsIm9mZnNldCIsbS5jXSxrLHIpKX1qLlk1KDAsbyxuKX1yZXR1
-cm4gUC5FRihbInJlZ2lvbnMiLGwuYSwibmF2aWdhdGlvbkNvbnRlbnQiLGwuYiwic291cmNlQ29kZSIs
-bC5jLCJlZGl0cyIsal0sayxyKX19ClQubVEucHJvdG90eXBlPXt9CkwuZS5wcm90b3R5cGU9ewokMTpm
-dW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbQp0LmFMLmEoYSkKcz13aW5kb3cubG9jYXRpb24ucGF0
-aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlvbi5ocmVmKQpxPUwuYUsod2luZG93LmxvY2F0aW9uLmhy
-ZWYpCkwuR2UoKQppZihzIT09Ii8iJiZzIT09Si5UMChkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucm9v
-dCIpLnRleHRDb250ZW50KSlMLkc3KHMscixxLCEwLG5ldyBMLlZXKHMscixxKSkKcD1kb2N1bWVudApv
-PUoucUYocC5xdWVyeVNlbGVjdG9yKCIuYXBwbHktbWlncmF0aW9uIikpCm49by4kdGkKbT1uLkMoIn4o
-MSk/IikuYShuZXcgTC5vWigpKQp0LlouYShudWxsKQpXLkpFKG8uYSxvLmIsbSwhMSxuLmMpCm49Si5x
-RihwLnF1ZXJ5U2VsZWN0b3IoIi5yZXJ1bi1taWdyYXRpb24iKSkKbT1uLiR0aQpXLkpFKG4uYSxuLmIs
-bS5DKCJ+KDEpPyIpLmEobmV3IEwuSGkoKSksITEsbS5jKQptPUoucUYocC5xdWVyeVNlbGVjdG9yKCIu
-cmVwb3J0LXByb2JsZW0iKSkKbj1tLiR0aQpXLkpFKG0uYSxtLmIsbi5DKCJ+KDEpPyIpLmEobmV3IEwu
-QlQoKSksITEsbi5jKQpwPUoucUYocC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSAuY2xvc2UiKSkK
-bj1wLiR0aQpXLkpFKHAuYSxwLmIsbi5DKCJ+KDEpPyIpLmEobmV3IEwuUFkoKSksITEsbi5jKQpuPUou
-cUYoJC5jMCgpKQpwPW4uJHRpClcuSkUobi5hLG4uYixwLkMoIn4oMSk/IikuYShuZXcgTC51OCgpKSwh
-MSxwLmMpfSwKJFM6MTl9CkwuVlcucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0
-aGlzLmIsdGhpcy5jKX0sCiRTOjJ9Ckwub1oucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMs
-cixxLHAsbwp0Lk8uYShhKQppZihILm9UKEMub2wudXMod2luZG93LCJUaGlzIHdpbGwgYXBwbHkgdGhl
-IGNoYW5nZXMgeW91J3ZlIHByZXZpZXdlZCB0byB5b3VyIHdvcmtpbmcgZGlyZWN0b3J5LiBJdCBpcyBy
-ZWNvbW1lbmRlZCB5b3UgY29tbWl0IGFueSBjaGFuZ2VzIHlvdSBtYWRlIGJlZm9yZSBkb2luZyB0aGlz
-LiIpKSl7cz1ILlZNKFtdLHQuRykKZm9yKHI9JC5JUixxPXIubGVuZ3RoLHA9MDtwPHIubGVuZ3RoO3Iu
-bGVuZ3RoPT09cXx8KDAsSC5saykociksKytwKXMucHVzaChyW3BdLkx0KCkpCnM9TC50eSgiL2FwcGx5
-LW1pZ3JhdGlvbiIsUC5FRihbIm5hdmlnYXRpb25UcmVlIixzXSx0LlgsdC5kcCkpLlc3KG5ldyBMLmpy
-KCksdC5QKQpvPW5ldyBMLnFsKCkKdC5iNy5hKG51bGwpCnI9cy4kdGkKcT0kLlgzCmlmKHEhPT1DLk5V
-KW89UC5WSChvLHEpCnMueGYobmV3IFAuRmUobmV3IFAudnMocSxyKSwyLG51bGwsbyxyLkMoIkA8MT4i
-KS5LcShyLmMpLkMoIkZlPDEsMj4iKSkpfX0sCiRTOjF9CkwuanIucHJvdG90eXBlPXsKJDE6ZnVuY3Rp
-b24oYSl7dmFyIHMKdC50LmEoYSkKcz1kb2N1bWVudC5ib2R5CnMuY2xhc3NMaXN0LnJlbW92ZSgicHJv
-cG9zZWQiKQpzLmNsYXNzTGlzdC5hZGQoImFwcGxpZWQiKX0sCiRTOjQzfQpMLnFsLnByb3RvdHlwZT17
-CiQyOmZ1bmN0aW9uKGEsYil7TC5DMigiQ291bGQgbm90IGFwcGx5IG1pZ3JhdGlvbiIsYSxiKX0sCiRD
-OiIkMiIsCiRSOjIsCiRTOjE3fQpMLkhpLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0
-aGlzLnhuKHQuTy5hKGEpKX0sCnhuOmZ1bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAs
-bz1bXSxuLG0sbCxrLGoKdmFyICRhc3luYyQkMT1QLmx6KGZ1bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9
-YwpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOnE9Mwpkb2N1bWVudC5ib2R5LmNsYXNzTGlz
-dC5hZGQoInJlcnVubmluZyIpCnM9NgpyZXR1cm4gUC5qUShMLnR5KCIvcmVydW4tbWlncmF0aW9uIixu
-dWxsKSwkYXN5bmMkJDEpCmNhc2UgNjpuPWMKaWYoSC5vVChILnk4KEoueDkobiwic3VjY2VzcyIpKSkp
-d2luZG93LmxvY2F0aW9uLnJlbG9hZCgpCmVsc2UgTC5LMCh0LmVFLmEoSi54OShuLCJlcnJvcnMiKSkp
-Cm8ucHVzaCg1KQpzPTQKYnJlYWsKY2FzZSAzOnE9MgpqPXAKbT1ILlJ1KGopCmw9SC50cyhqKQpMLkMy
-KCJGYWlsZWQgdG8gcmVydW4gbWlncmF0aW9uIixtLGwpCm8ucHVzaCg1KQpzPTQKYnJlYWsKY2FzZSAy
-Om89WzFdCmNhc2UgNDpxPTEKZG9jdW1lbnQuYm9keS5jbGFzc0xpc3QucmVtb3ZlKCJyZXJ1bm5pbmci
-KQpzPW8ucG9wKCkKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQ
-LmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJCQxLHIpfSwKJFM6MjB9CkwuQlQucHJvdG90eXBl
-PXsKJDE6ZnVuY3Rpb24oYSl7dC5PLmEoYSkKQy5vbC5Qbyh3aW5kb3csUC5YZCgiaHR0cHMiLCJnaXRo
+bmN0aW9uIFhXKCl7fSwKb2E6ZnVuY3Rpb24gb2EoKXt9fSxVPXsKamY6ZnVuY3Rpb24oYSl7dmFyIHMs
+cixxLHAKaWYoYT09bnVsbClzPW51bGwKZWxzZXtzPUguVk0oW10sdC5kNykKZm9yKHI9Si5JVCh0LlUu
+YShhKSk7ci5GKCk7KXtxPXIuZ2woKQpwPUouVTYocSkKcy5wdXNoKG5ldyBVLlNlKEguaChwLnEocSwi
+ZGVzY3JpcHRpb24iKSksSC5oKHAucShxLCJocmVmIikpKSl9fXJldHVybiBzfSwKTmQ6ZnVuY3Rpb24o
+YSl7dmFyIHMscgppZihhPT1udWxsKXM9bnVsbAplbHNle3M9SC5WTShbXSx0LmFBKQpmb3Iocj1KLklU
+KHQuVS5hKGEpKTtyLkYoKTspcy5wdXNoKFUuTmYoci5nbCgpKSl9cmV0dXJuIHN9LApOZjpmdW5jdGlv
+bihhKXt2YXIgcz1KLlU2KGEpLHI9SC5oKHMucShhLCJkZXNjcmlwdGlvbiIpKSxxPUguVk0oW10sdC5h
+SikKZm9yKHM9Si5JVCh0LlUuYShzLnEoYSwiZW50cmllcyIpKSk7cy5GKCk7KXEucHVzaChVLlJqKHMu
+Z2woKSkpCnJldHVybiBuZXcgVS55RChyLHEpfSwKUmo6ZnVuY3Rpb24oYSl7dmFyIHMscj1KLlU2KGEp
+LHE9SC5oKHIucShhLCJkZXNjcmlwdGlvbiIpKSxwPUguaChyLnEoYSwiZnVuY3Rpb24iKSksbz1yLnEo
+YSwibGluayIpCmlmKG89PW51bGwpbz1udWxsCmVsc2V7cz1KLlU2KG8pCm89bmV3IFUuTWwoSC5oKHMu
+cShvLCJocmVmIikpLEgudVAocy5xKG8sImxpbmUiKSksSC5oKHMucShvLCJwYXRoIikpKX1yPXQuZksu
+YShyLnEoYSwiaGludEFjdGlvbnMiKSkKcj1yPT1udWxsP251bGw6Si5NMShyLG5ldyBVLmFOKCksdC5h
+WCkKcj1yPT1udWxsP251bGw6ci5icigwKQpyZXR1cm4gbmV3IFUud2IocSxwLG8scj09bnVsbD9DLmRu
+OnIpfSwKZDI6ZnVuY3Rpb24gZDIoYSxiLGMsZCxlLGYpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5j
+PWMKXy5kPWQKXy5lPWUKXy5mPWZ9LApTZTpmdW5jdGlvbiBTZShhLGIpe3RoaXMuYT1hCnRoaXMuYj1i
+fSwKTWw6ZnVuY3Rpb24gTWwoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKeUQ6ZnVu
+Y3Rpb24geUQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCndiOmZ1bmN0aW9uIHdiKGEsYixjLGQpe3Zh
+ciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWR9LAphTjpmdW5jdGlvbiBhTigpe30sCmIwOmZ1
+bmN0aW9uIGIwKCl7fX0sQj17CndSOmZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBCLnFwKCIiLCIiLCIiLEMu
+RHgpfSwKWWY6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrPUguaChhLnEoMCwicmVnaW9u
+cyIpKSxqPUguaChhLnEoMCwibmF2aWdhdGlvbkNvbnRlbnQiKSksaT1ILmgoYS5xKDAsInNvdXJjZUNv
+ZGUiKSksaD1QLkZsKHQuWCx0LmRfKQpmb3Iocz10LnQuYShhLnEoMCwiZWRpdHMiKSkscz1zLmdQdShz
+KSxzPXMuZ20ocykscj10LlUscT10Lmg0O3MuRigpOyl7cD1zLmdsKCkKbz1wLmEKbj1ILlZNKFtdLHEp
+CmZvcihwPUouSVQoci5hKHAuYikpO3AuRigpOyl7bT1wLmdsKCkKbD1KLlU2KG0pCm4ucHVzaChuZXcg
+Qi5qOChILnVQKGwucShtLCJsaW5lIikpLEguaChsLnEobSwiZXhwbGFuYXRpb24iKSksSC51UChsLnEo
+bSwib2Zmc2V0IikpKSl9aC5ZNSgwLG8sbil9cmV0dXJuIG5ldyBCLnFwKGssaixpLGgpfSwKajg6ZnVu
+Y3Rpb24gajgoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKcXA6ZnVuY3Rpb24gcXAo
+YSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZH0sCmZ2OmZ1bmN0aW9uIGZ2
+KCl7fSwKT1M6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoIShhPj02NSYmYTw9OTApKXM9YT49OTcmJmE8PTEy
+MgplbHNlIHM9ITAKcmV0dXJuIHN9LApZdTpmdW5jdGlvbihhLGIpe3ZhciBzPWEubGVuZ3RoLHI9Yisy
+CmlmKHM8cilyZXR1cm4hMQppZighQi5PUyhDLnhCLk8oYSxiKSkpcmV0dXJuITEKaWYoQy54Qi5PKGEs
+YisxKSE9PTU4KXJldHVybiExCmlmKHM9PT1yKXJldHVybiEwCnJldHVybiBDLnhCLk8oYSxyKT09PTQ3
+fX0sVD17bVE6ZnVuY3Rpb24gbVEoKXt9fSxMPXsKSXE6ZnVuY3Rpb24oKXtDLkJaLkIoZG9jdW1lbnQs
+IkRPTUNvbnRlbnRMb2FkZWQiLG5ldyBMLmUoKSkKQy5vbC5CKHdpbmRvdywicG9wc3RhdGUiLG5ldyBM
+LkwoKSl9LAprejpmdW5jdGlvbihhKXt2YXIgcyxyPXQuZy5hKGEucGFyZW50Tm9kZSkucXVlcnlTZWxl
+Y3RvcigiOnNjb3BlID4gdWwiKSxxPXIuc3R5bGUscD0iIitDLkNELnpRKHIub2Zmc2V0SGVpZ2h0KSoy
+KyJweCIKcS5tYXhIZWlnaHQ9cApxPUoucUYoYSkKcD1xLiR0aQpzPXAuQygifigxKT8iKS5hKG5ldyBM
+Lld4KHIsYSkpCnQuWi5hKG51bGwpClcuSkUocS5hLHEuYixzLCExLHAuYyl9LAp5WDpmdW5jdGlvbihh
+LGIpe3ZhciBzLHIscSxwLG8sbixtPSJxdWVyeVNlbGVjdG9yQWxsIixsPWRvY3VtZW50LnF1ZXJ5U2Vs
+ZWN0b3IoYSksaz10LmcKbC50b1N0cmluZwpzPXQuaApILkRoKGsscywiVCIsbSkKcj10LlIKcT1uZXcg
+Vy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5uYXYtbGluayIpLHIpCnEuSyhxLG5ldyBMLkFPKGIpKQpI
+LkRoKGsscywiVCIsbSkKcD1uZXcgVy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5yZWdpb24iKSxyKQpp
+ZighcC5nbDAocCkpe289bC5xdWVyeVNlbGVjdG9yKCJ0YWJsZVtkYXRhLXBhdGhdIikKby50b1N0cmlu
+ZwpwLksocCxuZXcgTC5IbyhvLmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KG8p
+KS5PVSgicGF0aCIpKSkpfUguRGgoayxzLCJUIixtKQpuPW5ldyBXLnd6KGwucXVlcnlTZWxlY3RvckFs
+bCgiLmFkZC1oaW50LWxpbmsiKSxyKQpuLksobixuZXcgTC5JQygpKX0sClE2OmZ1bmN0aW9uKGEsYixj
+KXt2YXIgcz1uZXcgWE1MSHR0cFJlcXVlc3QoKQpDLkR0LmVvKHMsIkdFVCIsTC5RNChhLGIpLCEwKQpz
+LnNldFJlcXVlc3RIZWFkZXIoIkNvbnRlbnQtVHlwZSIsImFwcGxpY2F0aW9uL2pzb247IGNoYXJzZXQ9
+VVRGLTgiKQpyZXR1cm4gTC5MVShzLG51bGwsYy5DKCIwKiIpKX0sCnR5OmZ1bmN0aW9uKGEsYil7dmFy
+IHM9bmV3IFhNTEh0dHBSZXF1ZXN0KCkscj10LlgKQy5EdC5lbyhzLCJQT1NUIixMLlE0KGEsUC5GbChy
+LHIpKSwhMCkKcy5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9qc29u
+OyBjaGFyc2V0PVVURi04IikKcmV0dXJuIEwuTFUocyxiLHQudCl9LApMVTpmdW5jdGlvbihhLGIsYyl7
+cmV0dXJuIEwuVGcoYSxiLGMsYy5DKCIwKiIpKX0sClRnOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzPTAs
+cj1QLkZYKGQpLHEscD0yLG8sbj1bXSxtLGwsayxqLGksaCxnLGYKdmFyICRhc3luYyRMVT1QLmx6KGZ1
+bmN0aW9uKGUsYTApe2lmKGU9PT0xKXtvPWEwCnM9cH13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6
+aT1uZXcgUC5aZihuZXcgUC52cygkLlgzLHQuZ1YpLHQuYkMpCmg9dC5lYgpnPWguYShuZXcgTC5mQyhp
+LGEpKQp0LlouYShudWxsKQpsPXQuZVEKVy5KRShhLCJsb2FkIixnLCExLGwpClcuSkUoYSwiZXJyb3Ii
+LGguYShpLmdZSigpKSwhMSxsKQphLnNlbmQoYj09bnVsbD9udWxsOkMuQ3QuT0IoYixudWxsKSkKcD00
+CnM9NwpyZXR1cm4gUC5qUShpLmEsJGFzeW5jJExVKQpjYXNlIDc6cD0yCnM9NgpicmVhawpjYXNlIDQ6
+cD0zCmY9bwpILlJ1KGYpCm09SC50cyhmKQpoPVAuVGwoIkVycm9yIHJlYWNoaW5nIG1pZ3JhdGlvbiBw
+cmV2aWV3IHNlcnZlci4iLG0pCnRocm93IEguYihoKQpzPTYKYnJlYWsKY2FzZSAzOnM9MgpicmVhawpj
+YXNlIDY6aj1DLkN0LnBXKDAsYS5yZXNwb25zZVRleHQsbnVsbCkKaWYoYS5zdGF0dXM9PT0yMDApe3E9
+Yy5DKCIwKiIpLmEoaikKcz0xCmJyZWFrfWVsc2UgdGhyb3cgSC5iKGopCmNhc2UgMTpyZXR1cm4gUC55
+QyhxLHIpCmNhc2UgMjpyZXR1cm4gUC5mMyhvLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRMVSxyKX0s
+CmFLOmZ1bmN0aW9uKGEpe3ZhciBzPVAuaEsoYSkuZ2hZKCkucSgwLCJsaW5lIikKcmV0dXJuIHM9PW51
+bGw/bnVsbDpILkhwKHMsbnVsbCl9LApHNjpmdW5jdGlvbihhKXt2YXIgcz1QLmhLKGEpLmdoWSgpLnEo
+MCwib2Zmc2V0IikKcmV0dXJuIHM9PW51bGw/bnVsbDpILkhwKHMsbnVsbCl9LAppNjpmdW5jdGlvbihh
+KXtyZXR1cm4gTC5uVyh0Lk8uYShhKSl9LApuVzpmdW5jdGlvbihhKXt2YXIgcz0wLHI9UC5GWCh0Lnop
+LHE9MSxwLG89W10sbixtLGwsayxqLGksaAp2YXIgJGFzeW5jJGk2PVAubHooZnVuY3Rpb24oYixjKXtp
+ZihiPT09MSl7cD1jCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6aT10LmcuYShXLnFjKGEu
+Y3VycmVudFRhcmdldCkpLmdldEF0dHJpYnV0ZSgiaHJlZiIpCmEucHJldmVudERlZmF1bHQoKQpxPTMK
+az1kb2N1bWVudApuPUMuQ0QuelEoay5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkK
+cz02CnJldHVybiBQLmpRKEwudHkoaSxudWxsKSwkYXN5bmMkaTYpCmNhc2UgNjpzPTcKcmV0dXJuIFAu
+alEoTC5HNyh3aW5kb3cubG9jYXRpb24ucGF0aG5hbWUsbnVsbCxudWxsLCExLG51bGwpLCRhc3luYyRp
+NikKY2FzZSA3Oms9ay5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpCmsudG9TdHJpbmcKay5zY3JvbGxU
+b3A9Si5WdShuKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKaD1wCm09SC5SdShoKQpsPUgudHMoaCkK
+TC5DMigiQ291bGQgbm90IGFkZC9yZW1vdmUgaGludCIsbSxsKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpi
+cmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpy
+ZXR1cm4gUC5ESSgkYXN5bmMkaTYscil9LApDMjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHA9ImV4
+Y2VwdGlvbiIsbz0ic3RhY2tUcmFjZSIsbj10LnQuYihiKSYmSi5STShiLnEoMCwic3VjY2VzcyIpLCEx
+KSYmYi54NChwKSYmYi54NChvKSxtPUouaWEoYikKaWYobil7cz1ILmgobS5xKGIscCkpCmM9bS5xKGIs
+byl9ZWxzZSBzPW0udyhiKQpuPWRvY3VtZW50CnI9bi5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIp
+CnIucXVlcnlTZWxlY3RvcigiaDIiKS5pbm5lclRleHQ9YQpyLnF1ZXJ5U2VsZWN0b3IoInAiKS5pbm5l
+clRleHQ9cwpyLnF1ZXJ5U2VsZWN0b3IoInByZSIpLmlubmVyVGV4dD1KLmooYykKcT10LmRkLmEoci5x
+dWVyeVNlbGVjdG9yKCJhLmJvdHRvbSIpKTsocSYmQy54bikuc0xVKHEsUC5YZCgiaHR0cHMiLCJnaXRo
dWIuY29tIiwiZGFydC1sYW5nL3Nkay9pc3N1ZXMvbmV3IixQLkVGKFsidGl0bGUiLCJDdXN0b21lci1y
-ZXBvcnRlZCBpc3N1ZSB3aXRoIE5OQkQgbWlncmF0aW9uIHRvb2wiLCJsYWJlbHMiLHUuZCwiYm9keSIs
-IiMjIyMgU3RlcHMgdG8gcmVwcm9kdWNlXG5cbiMjIyMgV2hhdCBkaWQgeW91IGV4cGVjdCB0byBoYXBw
-ZW4/XG5cbiMjIyMgV2hhdCBhY3R1YWxseSBoYXBwZW5lZD9cblxuX1NjcmVlbnNob3RzIGFyZSBhcHBy
-ZWNpYXRlZF9cblxuKipEYXJ0IFNESyB2ZXJzaW9uKio6ICIrSC5Faihkb2N1bWVudC5nZXRFbGVtZW50
-QnlJZCgic2RrLXZlcnNpb24iKS50ZXh0Q29udGVudCkrIlxuXG5UaGFua3MgZm9yIGZpbGluZyFcbiJd
-LHQuWCx0LnopKS5nbkQoKSwicmVwb3J0LXByb2JsZW0iKX0sCiRTOjF9CkwuUFkucHJvdG90eXBlPXsK
-JDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC5PLmEoYSkKcz1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucG9w
-dXAtcGFuZSIpLnN0eWxlCnMuZGlzcGxheT0ibm9uZSIKcmV0dXJuIm5vbmUifSwKJFM6NDV9CkwudTgu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAKdC5PLmEoYSkKcz0kLkQ5KCkuaW5u
-ZXJUZXh0CnI9dC5nLmEoZG9jdW1lbnQucXVlcnlTZWxlY3RvcignLm5hdi1wYW5lbCBbZGF0YS1uYW1l
-Kj0iJytILkVqKHMpKyciXScpLnBhcmVudE5vZGUpCnE9ci5xdWVyeVNlbGVjdG9yKCIuc3RhdHVzLWlj
-b24iKQpwPUwubUgoJC5JUixzKQppZihwIGluc3RhbmNlb2YgTC5jRCYmSC5vVChwLngpKXtMLk90KHAp
-CkwueG4ocSxwKQpMLkFSKHIscCl9fSwKJFM6MX0KTC5MLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
-e3ZhciBzLHIscQp0LmFMLmEoYSkKcz13aW5kb3cubG9jYXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRv
-dy5sb2NhdGlvbi5ocmVmKQpxPUwuYUsod2luZG93LmxvY2F0aW9uLmhyZWYpCmlmKHMubGVuZ3RoPjEp
-TC5HNyhzLHIscSwhMSxudWxsKQplbHNle0wuQkUocyxCLndSKCksITApCkwuQlgoIiZuYnNwOyIsbnVs
-bCl9fSwKJFM6MTl9CkwuV3gucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9ImNv
-bGxhcHNlZCIKdC5PLmEoYSkKcz10aGlzLmEKcj1KLllFKHMpCnE9dGhpcy5iCmlmKCFyLmdQKHMpLnRn
-KDAscCkpe3IuZ1AocykuaSgwLHApCkouZFIocSkuaSgwLHApfWVsc2V7ci5nUChzKS5SKDAscCkKSi5k
-UihxKS5SKDAscCl9fSwKJFM6MX0KTC5BTy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcz1K
-LnFGKHQuZy5hKGEpKSxyPXMuJHRpLHE9ci5DKCJ+KDEpPyIpLmEobmV3IEwuZE4odGhpcy5hKSkKdC5a
-LmEobnVsbCkKVy5KRShzLmEscy5iLHEsITEsci5jKX0sCiRTOjN9CkwuZE4ucHJvdG90eXBlPXsKJDE6
-ZnVuY3Rpb24oYSl7cmV0dXJuIEwudDIodC5PLmEoYSksdGhpcy5hKX0sCiRTOjd9CkwuSG8ucHJvdG90
-eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuZy5hKGEpCnM9Si5xRihhKQpyPXMuJHRpCnE9
-ci5DKCJ+KDEpPyIpLmEobmV3IEwueHooYSx0aGlzLmEpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIs
-cSwhMSxyLmMpfSwKJFM6M30KTC54ei5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8u
-YShhKQpzPXRoaXMuYQpMLmhYKHRoaXMuYixQLlFBKHMuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcu
-U3kobmV3IFcuaTcocykpLk9VKCJvZmZzZXQiKSksbnVsbCksUC5RQShzLmdldEF0dHJpYnV0ZSgiZGF0
-YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5PVSgibGluZSIpKSxudWxsKSl9LAokUzoxfQpMLklDLnBy
-b3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPUoucUYodC5nLmEoYSkpLHI9cy4kdGkKci5DKCJ+
-KDEpPyIpLmEoTC5pUygpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIsTC5pUygpLCExLHIuYyl9LAok
-UzozfQpMLmZDLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuZVEuYShhKQp0aGlzLmEuYU0oMCx0
-aGlzLmIpfSwKJFM6NDh9CkwublQucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0
-aGlzLmIsdGhpcy5jKX0sCiRTOjJ9CkwuTlkucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRo
-aXMuYSxudWxsLG51bGwpfSwKJFM6Mn0KTC51ZS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0LmF3
-LmEoYSkKcmV0dXJuIEguRWooYS5xKDAsInNldmVyaXR5IikpKyIgLSAiK0guRWooYS5xKDAsIm1lc3Nh
-Z2UiKSkrIiBhdCAiK0guRWooYS5xKDAsImxvY2F0aW9uIikpKyIgLSAoIitILkVqKGEucSgwLCJjb2Rl
-IikpKyIpIn0sCiRTOjQ5fQpMLmVYLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuZy5hKGEpCiQu
-ekIoKS50b1N0cmluZwp0LmRILmEoJC5vdygpLnEoMCwiaGxqcyIpKS5WNygiaGlnaGxpZ2h0QmxvY2si
-LFthXSl9LAokUzozfQpMLkVFLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdC5PLmEo
-YSkucHJldmVudERlZmF1bHQoKQpzPXRoaXMuYQpyPXRoaXMuYgpMLmFmKHdpbmRvdy5sb2NhdGlvbi5w
-YXRobmFtZSxzLHIsITAsbmV3IEwuUUwocyxyKSkKTC5oWCh0aGlzLmMscyxyKX0sCiRTOjF9CkwuUUwu
-cHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHdpbmRvdy5sb2NhdGlvbi5wYXRobmFtZSx0aGlz
-LmEsdGhpcy5iKX0sCiRTOjJ9CkwuVlMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscj0i
-c2VsZWN0ZWQtZmlsZSIKdC5nLmEoYSkKYS50b1N0cmluZwpzPUouWUUoYSkKaWYoYS5nZXRBdHRyaWJ1
-dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhhKSkuT1UoIm5hbWUiKSk9PT10aGlzLmEuYSlzLmdQ
-KGEpLmkoMCxyKQplbHNlIHMuZ1AoYSkuUigwLHIpfSwKJFM6M30KTC5URC5wcm90b3R5cGU9ewokMTpm
-dW5jdGlvbihhKXt2YXIgcyxyCnQuTy5hKGEpCnM9dGhpcy5hCnN3aXRjaChzLmdMKCkpe2Nhc2UgQy5j
-dzpicmVhawpjYXNlIEMuV0Q6cy5uRygpCmJyZWFrCmNhc2UgQy5YajpzLmMyKCkKYnJlYWsKY2FzZSBD
-LmRjOnMuYzIoKQpicmVha31yPXRoaXMuYgpMLmhsKHIscykKTC54bih0aGlzLmMscykKTC5BUihyLHMp
-fSwKJFM6MX0KTC5JZi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPXRo
-aXMuYQpMLk90KHMpCkwueG4odGhpcy5iLHMpCkwuQVIodGhpcy5jLHMpfSwKJFM6MX0KTC50Qi5wcm90
-b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gTC50Mih0Lk8uYShhKSwhMCl9LAokUzo3fQpMLm0y
-LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlJJKHQuTy5hKGEpKX0sClJJOmZ1
-bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuPXRoaXMsbSxsLGssaixpLGgs
-ZyxmCnZhciAkYXN5bmMkJDE9UC5seihmdW5jdGlvbihiLGMpe2lmKGI9PT0xKXtwPWMKcz1xfXdoaWxl
-KHRydWUpc3dpdGNoKHMpe2Nhc2UgMDpxPTMKaT1kb2N1bWVudAptPUMuQ0QuelEoaS5xdWVyeVNlbGVj
-dG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkKaD10LlgKcz02CnJldHVybiBQLmpRKEwudHkoTC5RNCgi
-L2FwcGx5LWhpbnQiLFAuRmwoaCxoKSksbi5hLkx0KCkpLCRhc3luYyQkMSkKY2FzZSA2Omg9bi5iCmw9
-TC5VcyhoLmEpCnM9NwpyZXR1cm4gUC5qUShMLkc3KGwsbnVsbCxoLmIsITEsbnVsbCksJGFzeW5jJCQx
-KQpjYXNlIDc6aS5ib2R5LmNsYXNzTGlzdC5hZGQoIm5lZWRzLXJlcnVuIikKaT1pLnF1ZXJ5U2VsZWN0
-b3IoIi5jb250ZW50IikKaS50b1N0cmluZwppLnNjcm9sbFRvcD1KLlZ1KG0pCnE9MQpzPTUKYnJlYWsK
-Y2FzZSAzOnE9MgpmPXAKaz1ILlJ1KGYpCmo9SC50cyhmKQpMLkMyKCJDb3VsZCBub3QgYXBwbHkgaGlu
-dCIsayxqKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxy
-KQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkJDEscil9LAokUzoy
-MH0KTC5YQS5wcm90b3R5cGU9ewpFYjpmdW5jdGlvbihhLGIsYyl7cmV0dXJuITB9LAppMDpmdW5jdGlv
-bihhKXtyZXR1cm4hMH0sCiRpa0Y6MX0KTC52dC5wcm90b3R5cGU9ewpnTDpmdW5jdGlvbigpe3ZhciBz
-LHIscSxwLG8sbixtLGw9dGhpcy5kCmlmKGwubGVuZ3RoPT09MClyZXR1cm4gQy5jdwpzPUMuTm0uZ3RI
-KGwpLmdMKCkKZm9yKHI9bC5sZW5ndGgscT0hMCxwPSEwLG89MDtvPGwubGVuZ3RoO2wubGVuZ3RoPT09
-cnx8KDAsSC5saykobCksKytvKXtuPWxbb10uZ0woKQppZihuIT1zKXM9bnVsbAptPW4hPT1DLmN3Cmlm
-KG0mJm4hPT1DLldEKXE9ITEKaWYobSYmbiE9PUMuWGopcD0hMX1pZihzIT1udWxsKXJldHVybiBzCmlm
-KHEpcmV0dXJuIEMuV0QKaWYocClyZXR1cm4gQy5YagpyZXR1cm4gQy5kY30sCkxWOmZ1bmN0aW9uKCl7
-dmFyIHMscixxPXRoaXMuZAppZihxIT1udWxsKWZvcihzPXEubGVuZ3RoLHI9MDtyPHM7KytyKXFbcl0u
-Yj10aGlzfSwKYzI6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscApmb3Iocz10aGlzLmQscj1zLmxlbmd0aCxx
-PTA7cTxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsrcSl7cD1zW3FdCmlmKHAgaW5z
-dGFuY2VvZiBMLnZ0KXAuYzIoKQplbHNlIGlmKHAgaW5zdGFuY2VvZiBMLmNEJiZILm9UKHAueCkmJnAu
-cj09PUMuWGopcC5yPUMuV0R9fSwKbkc6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscApmb3Iocz10aGlzLmQs
-cj1zLmxlbmd0aCxxPTA7cTxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsrcSl7cD1z
-W3FdCmlmKHAgaW5zdGFuY2VvZiBMLnZ0KXAubkcoKQplbHNlIGlmKHAgaW5zdGFuY2VvZiBMLmNEJiZI
-Lm9UKHAueCkmJnAucj09PUMuV0QpcC5yPUMuWGp9fSwKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyPVAuRmwo
-dC5YLHQuXykKci5ZNSgwLCJ0eXBlIiwiZGlyZWN0b3J5IikKci5ZNSgwLCJuYW1lIix0aGlzLmEpCnIu
-WTUoMCwic3VidHJlZSIsTC5WRCh0aGlzLmQpKQpzPXRoaXMuYwppZihzIT1udWxsKXIuWTUoMCwicGF0
-aCIscykKcmV0dXJuIHJ9fQpMLmNELnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlz
-LHE9UC5GbCh0LlgsdC5fKQpxLlk1KDAsInR5cGUiLCJmaWxlIikKcS5ZNSgwLCJuYW1lIixyLmEpCnM9
-ci5jCmlmKHMhPW51bGwpcS5ZNSgwLCJwYXRoIixzKQpzPXIuZAppZihzIT1udWxsKXEuWTUoMCwiaHJl
-ZiIscykKcz1yLmUKaWYocyE9bnVsbClxLlk1KDAsImVkaXRDb3VudCIscykKcz1yLmYKaWYocyE9bnVs
-bClxLlk1KDAsIndhc0V4cGxpY2l0bHlPcHRlZE91dCIscykKcz1yLnIKaWYocyE9bnVsbClxLlk1KDAs
-Im1pZ3JhdGlvblN0YXR1cyIscy5hKQpzPXIueAppZihzIT1udWxsKXEuWTUoMCwibWlncmF0aW9uU3Rh
-dHVzQ2FuQmVDaGFuZ2VkIixzKQpyZXR1cm4gcX0sCmdMOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMucn19
-CkwuRDgucHJvdG90eXBlPXt9CkwuTzkucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
-cy5ifX0KTC5HYi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmJ9fQpNLmxJLnBy
-b3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7dmFyIHM9RC5hYigpCnJldHVybiBzfSwKV086ZnVuY3Rpb24o
-YSxiKXt2YXIgcyxyLHE9dC5kNApNLllGKCJhYnNvbHV0ZSIsSC5WTShbYixudWxsLG51bGwsbnVsbCxu
-dWxsLG51bGwsbnVsbF0scSkpCnM9dGhpcy5hCnM9cy5ZcihiKT4wJiYhcy5oSyhiKQppZihzKXJldHVy
-biBiCnI9SC5WTShbdGhpcy5nbCgpLGIsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLG51bGxdLHEpCk0u
-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
-Nn0KTS5Oby5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILmsoYSkKcmV0dXJuIGE9PW51bGw/Im51
-bGwiOiciJythKyciJ30sCiRTOjUwfQpCLmZ2LnByb3RvdHlwZT17CnhaOmZ1bmN0aW9uKGEpe3ZhciBz
-LHI9dGhpcy5ZcihhKQppZihyPjApcmV0dXJuIEoubGQoYSwwLHIpCmlmKHRoaXMuaEsoYSkpe2lmKDA+
-PWEubGVuZ3RoKXJldHVybiBILk9IKGEsMCkKcz1hWzBdfWVsc2Ugcz1udWxsCnJldHVybiBzfSwKTmM6
-ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYT09Yn19ClguV0QucHJvdG90eXBlPXsKSXg6ZnVuY3Rpb24oKXt2
-YXIgcyxyLHE9dGhpcwp3aGlsZSghMCl7cz1xLmQKaWYoIShzLmxlbmd0aCE9PTAmJkouUk0oQy5ObS5n
-cloocyksIiIpKSlicmVhawpzPXEuZAppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBv
-cCgpCnM9cS5lCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCl9cz1xLmUKcj1z
-Lmxlbmd0aAppZihyIT09MClDLk5tLlk1KHMsci0xLCIiKX0sCnJSOmZ1bmN0aW9uKCl7dmFyIHMscixx
-LHAsbyxuLG09dGhpcyxsPUguVk0oW10sdC5zKQpmb3Iocz1tLmQscj1zLmxlbmd0aCxxPTAscD0wO3A8
-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
-cmV0dXJuIHEKaWYoIUMueEIubihhLCJmaWxlOi8vIikpcmV0dXJuIHEKaWYoIUIuWXUoYSxxKzEpKXJl
-dHVybiBxCnA9cSszCnJldHVybiBvPT09cD9wOnErNH19cmV0dXJuIDB9LApZcjpmdW5jdGlvbihhKXty
-ZXR1cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aCE9PTAmJkMu
-eEIuVyhhLDApPT09NDd9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4idXJsIn0sCmdtSTpmdW5jdGlvbigp
-e3JldHVybiIvIn19CkwuSVYucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7cmV0dXJuIEMueEIudGco
-YSwiLyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N3x8YT09PTkyfSwKZHM6ZnVuY3Rpb24o
-YSl7dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKcz1DLnhCLk8oYSxzLTEpCnJldHVybiEo
-cz09PTQ3fHxzPT09OTIpfSwKU3A6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9YS5sZW5ndGgKaWYocT09
-PTApcmV0dXJuIDAKcz1DLnhCLlcoYSwwKQppZihzPT09NDcpcmV0dXJuIDEKaWYocz09PTkyKXtpZihx
-PDJ8fEMueEIuVyhhLDEpIT09OTIpcmV0dXJuIDEKcj1DLnhCLlhVKGEsIlxcIiwyKQppZihyPjApe3I9
-Qy54Qi5YVShhLCJcXCIscisxKQppZihyPjApcmV0dXJuIHJ9cmV0dXJuIHF9aWYocTwzKXJldHVybiAw
-CmlmKCFCLk9TKHMpKXJldHVybiAwCmlmKEMueEIuVyhhLDEpIT09NTgpcmV0dXJuIDAKcT1DLnhCLlco
-YSwyKQppZighKHE9PT00N3x8cT09PTkyKSlyZXR1cm4gMApyZXR1cm4gM30sCllyOmZ1bmN0aW9uKGEp
-e3JldHVybiB0aGlzLlNwKGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuWXIoYSk9PT0x
-fSwKT3Q6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihhPT09YilyZXR1cm4hMAppZihhPT09NDcpcmV0dXJu
-IGI9PT05MgppZihhPT09OTIpcmV0dXJuIGI9PT00NwppZigoYV5iKSE9PTMyKXJldHVybiExCnM9YXwz
-MgpyZXR1cm4gcz49OTcmJnM8PTEyMn0sCk5jOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxCmlmKGE9PWIp
-cmV0dXJuITAKcz1hLmxlbmd0aAppZihzIT09Yi5sZW5ndGgpcmV0dXJuITEKZm9yKHI9Si5yWShiKSxx
-PTA7cTxzOysrcSlpZighdGhpcy5PdChDLnhCLlcoYSxxKSxyLlcoYixxKSkpcmV0dXJuITEKcmV0dXJu
-ITB9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4id2luZG93cyJ9LApnbUk6ZnVuY3Rpb24oKXtyZXR1cm4i
-XFwifX07KGZ1bmN0aW9uIGFsaWFzZXMoKXt2YXIgcz1KLkd2LnByb3RvdHlwZQpzLlU9cy53CnMuU2o9
-cy5lNwpzPUouTUYucHJvdG90eXBlCnMudD1zLncKcz1QLmNYLnByb3RvdHlwZQpzLkdHPXMuZXYKcz1Q
-Lk1oLnByb3RvdHlwZQpzLnhiPXMudwpzPVcuY3YucHJvdG90eXBlCnMuRFc9cy5yNgpzPVcubTYucHJv
-dG90eXBlCnMuakY9cy5FYgpzPVAuRTQucHJvdG90eXBlCnMuVXI9cy5xCnMuZTQ9cy5ZNQpzPVAuY28u
-cHJvdG90eXBlCnMuYmg9cy5ZNX0pKCk7KGZ1bmN0aW9uIGluc3RhbGxUZWFyT2Zmcygpe3ZhciBzPWh1
-bmtIZWxwZXJzLl9zdGF0aWNfMSxyPWh1bmtIZWxwZXJzLl9zdGF0aWNfMCxxPWh1bmtIZWxwZXJzLmlu
-c3RhbGxJbnN0YW5jZVRlYXJPZmYscD1odW5rSGVscGVycy5pbnN0YWxsU3RhdGljVGVhck9mZixvPWh1
-bmtIZWxwZXJzLl9pbnN0YW5jZV8xdQpzKFAsIkVYIiwiWlYiLDgpCnMoUCwieXQiLCJvQSIsOCkKcyhQ
-LCJxVyIsIkJ6Iiw4KQpyKFAsIlVJIiwiZU4iLDApCnEoUC5QZi5wcm90b3R5cGUsImdZSiIsMCwxLG51
-bGwsWyIkMiIsIiQxIl0sWyJ3MCIsInBtIl0sMjgsMCkKcyhQLCJDeSIsIk5DIiw0KQpzKFAsIlBIIiwi
-TXQiLDUpCnAoVywicFMiLDQsbnVsbCxbIiQ0Il0sWyJxRCJdLDksMCkKcChXLCJWNCIsNCxudWxsLFsi
-JDQiXSxbIlFXIl0sOSwwKQpvKFAuQXMucHJvdG90eXBlLCJndU0iLCJWIiw1KQpzKFAsImlHIiwid1ki
-LDUzKQpzKFAsIncwIiwiZFUiLDM2KQpzKEwsImlTIiwiaTYiLDcpfSkoKTsoZnVuY3Rpb24gaW5oZXJp
-dGFuY2UoKXt2YXIgcz1odW5rSGVscGVycy5taXhpbixyPWh1bmtIZWxwZXJzLmluaGVyaXQscT1odW5r
-SGVscGVycy5pbmhlcml0TWFueQpyKFAuTWgsbnVsbCkKcShQLk1oLFtILkZLLEouR3YsSi5tMSxQLmNY
-LEguRTcsUC5YUyxQLm5ZLEguYTcsUC5BbixILkZ1LEguSkIsSC5TVSxILlJlLEgud3YsUC5QbixILldV
-LEguTEksSC5UcCxILmY5LEgudGUsSC5icSxILlhPLEgua3IsUC5ZayxILnZoLEguTjYsSC5WUixILkVL
-LEguUGIsSC50USxILlNkLEguSmMsSC5HLEgubFksUC5XMyxQLmloLFAuRnksUC5HVixQLkN3LFAuUGYs
-UC5GZSxQLnZzLFAuT00sUC5xaCxQLk1PLFAua1QsUC54SSxQLm0wLFAucFIsUC5ibixQLmxtLFAubEQs
-UC5LUCxQLmxmLFAuV1ksUC5VayxQLlNoLFAuUncsUC5ieixQLmlQLFAuazUsUC5LWSxQLkNELFAuYUUs
-UC5OMyxQLmM4LFAuWmQsUC5SbixQLkRuLFAuUEUsUC5VZixXLmlkLFcuRmssVy5KUSxXLkdtLFcudkQs
-Vy5tNixXLk93LFcuVzksVy5kVyxXLm1rLFcuS28sUC5pSixQLkU0LE0uSDcsVS5MTCxVLmQyLFUuU2Us
-VS5NbCxVLnlELFUud2IsQi5qOCxCLnFwLFQubVEsTC5YQSxMLkQ4LEwuTzksTC5HYixNLmxJLE8uekws
-WC5XRCxYLmR2XSkKcShKLkd2LFtKLnlFLEoud2UsSi5NRixKLmpkLEoucUksSi5EcixILkVULFcuRDAs
-Vy5BeixXLkxlLFcuTmgsVy5hZSxXLklCLFcubjcsVy5lYSxXLmJyLFcuU2csVy53NyxXLks3LFcuWFcs
-UC5oRl0pCnEoSi5NRixbSi5pQyxKLmtkLEouYzVdKQpyKEouUG8sSi5qZCkKcShKLnFJLFtKLmJVLEou
-VkFdKQpxKFAuY1gsW0guQlIsSC5iUSxILmkxLEguVTUsSC5BTSxILnU2LEguWFIsUC5tVyxILnVuXSkK
-cShILkJSLFtILlp5LEguUUNdKQpyKEgub2wsSC5aeSkKcihILlVxLEguUUMpCnIoSC5qVixILlVxKQpx
-KFAuWFMsW0gubixILnIzLEguR00sUC5FeixILmF6LEgudlYsSC5FcSxQLkM2LEgua1MsUC5VZCxQLkYs
-UC51LFAubXAsUC51YixQLmRzLFAubGosUC5VVixQLmNdKQpyKFAudXksUC5uWSkKcShQLnV5LFtILncy
-LFcud3osVy5lN10pCnIoSC5xaixILncyKQpxKEguYlEsW0guYUwsSC5NQixILmk1XSkKcShILmFMLFtI
-Lm5ILEgubEosUC5pOF0pCnIoSC54eSxILmkxKQpxKFAuQW4sW0guTUgsSC5TTyxILlUxXSkKcihILmQ1
-LEguQU0pCnIoUC5SVSxQLlBuKQpyKFAuR2osUC5SVSkKcihILlBELFAuR2opCnIoSC5MUCxILldVKQpx
-KEguVHAsW0guQ2osSC5sYyxILmRDLEgud04sSC5WWCxQLnRoLFAuaGEsUC5WcyxQLkZ0LFAueUgsUC5X
-TSxQLlNYLFAuR3MsUC5kYSxQLm9RLFAucFYsUC5VNyxQLnZyLFAucnQsUC5LRixQLlpMLFAuUlQsUC5q
-WixQLnJxLFAuUlcsUC5CNSxQLnVPLFAucEssUC5oaixQLlZwLFAuT1IsUC5yYSxQLnlRLFAueHIsUC5O
-eixQLnRpLFAuV0YsUC5uMSxQLmNTLFAuVkMsUC5KVCxQLlJaLFAuTUUsUC55NSxQLnlJLFAuYzYsUC5x
-ZCxXLkN2LFcuS1MsVy5BMyxXLnZOLFcuVXYsVy5FZyxXLkVvLFcuV2ssVy5JQSxXLmZtLFAuamcsUC5U
-YSxQLkdFLFAuTjcsUC51USxQLlBDLFAubXQsUC5RUyxQLm5wLFAuVXQsVS5NRCxVLmFOLFUuYjAsTC5l
-LEwuVlcsTC5vWixMLmpyLEwucWwsTC5IaSxMLkJULEwuUFksTC51OCxMLkwsTC5XeCxMLkFPLEwuZE4s
-TC5IbyxMLnh6LEwuSUMsTC5mQyxMLm5ULEwuTlksTC51ZSxMLmVYLEwuRUUsTC5RTCxMLlZTLEwuVEQs
-TC5JZixMLnRCLEwubTIsTS5xNyxNLk5vXSkKcihILlcwLFAuRXopCnEoSC5sYyxbSC56eCxILnJUXSkK
-cihILmtZLFAuQzYpCnIoUC5pbCxQLllrKQpxKFAuaWwsW0guTjUsUC51dyxXLmNmLFcuU3ldKQpxKFAu
-bVcsW0guS1csUC5xNF0pCnIoSC5MWixILkVUKQpxKEguTFosW0guUkcsSC5XQl0pCnIoSC5WUCxILlJH
-KQpyKEguRGcsSC5WUCkKcihILlpHLEguV0IpCnIoSC5QZyxILlpHKQpxKEguUGcsW0gueGosSC5kRSxI
-LlpBLEguZFQsSC5QcSxILmVFLEguVjZdKQpyKEguaU0sSC5rUykKcihQLlpmLFAuUGYpCnIoUC5KaSxQ
-Lm0wKQpyKFAuWHYsUC5wUikKcihQLmI2LFAuWHYpCnIoUC5WaixQLldZKQpxKFAuVWssW1AuQ1YsUC5a
-aSxQLmJ5XSkKcihQLndJLFAua1QpCnEoUC53SSxbUC5VOCxQLm9qLFAuTXgsUC5FMyxQLkdZXSkKcihQ
-Lks4LFAuVWQpCnIoUC50dSxQLlNoKQpyKFAudTUsUC5aaSkKcShQLnUsW1AuYkosUC5lWV0pCnIoUC5x
-ZSxQLkRuKQpxKFcuRDAsW1cudUgsVy53YSxXLks1LFcuQ21dKQpxKFcudUgsW1cuY3YsVy5ueCxXLlFG
-LFcuQ1FdKQpxKFcuY3YsW1cucUUsUC5oaV0pCnEoVy5xRSxbVy5HaCxXLmZZLFcubkIsVy5RUCxXLmg0
-LFcuU04sVy5scCxXLlRiLFcuSXYsVy5XUCxXLnlZXSkKcihXLm9KLFcuTGUpCnIoVy5oSCxXLkF6KQpy
-KFcuVmIsVy5RRikKcihXLmZKLFcud2EpCnEoVy5lYSxbVy53NixXLmV3XSkKcihXLkFqLFcudzYpCnIo
-Vy5yQixXLks3KQpyKFcuQkgsVy5yQikKcihXLnc0LFcuSUIpCnIoVy5vYSxXLlhXKQpyKFcucmgsVy5v
-YSkKcihXLmk3LFcuY2YpCnIoUC5BcyxQLlZqKQpxKFAuQXMsW1cuSTQsUC5LZV0pCnIoVy5STyxQLnFo
-KQpyKFcuZXUsVy5STykKcihXLnhDLFAuTU8pCnIoVy5jdCxXLm02KQpyKFAuQmYsUC5pSikKcShQLkU0
-LFtQLnI3LFAuY29dKQpyKFAuVHosUC5jbykKcihQLm5kLFAuaGkpCnEoTC5EOCxbTC52dCxMLmNEXSkK
-cihCLmZ2LE8uekwpCnEoQi5mdixbRS5PRixGLnJ1LEwuSVZdKQpzKEgudzIsSC5SZSkKcyhILlFDLFAu
-bEQpCnMoSC5SRyxQLmxEKQpzKEguVlAsSC5TVSkKcyhILldCLFAubEQpCnMoSC5aRyxILlNVKQpzKFAu
-blksUC5sRCkKcyhQLldZLFAubGYpCnMoUC5SVSxQLktQKQpzKFAucFIsUC5sZikKcyhXLkxlLFcuaWQp
-CnMoVy5LNyxQLmxEKQpzKFcuckIsVy5HbSkKcyhXLlhXLFAubEQpCnMoVy5vYSxXLkdtKQpzKFAuY28s
-UC5sRCl9KSgpCnZhciB2PXt0eXBlVW5pdmVyc2U6e2VDOm5ldyBNYXAoKSx0Ujp7fSxlVDp7fSx0UFY6
-e30sc0VBOltdfSxtYW5nbGVkR2xvYmFsTmFtZXM6e0IyOiJpbnQiLENQOiJkb3VibGUiLFpaOiJudW0i
-LHFVOiJTdHJpbmciLGEyOiJib29sIixjODoiTnVsbCIsek06Ikxpc3QifSxtYW5nbGVkTmFtZXM6e30s
-Z2V0VHlwZUZyb21OYW1lOmdldEdsb2JhbEZyb21OYW1lLG1ldGFkYXRhOltdLHR5cGVzOlsifigpIiwi
-YzgoQWoqKSIsImM4KCkiLCJjOChjdiopIiwiQChAKSIsInFVKHFVKSIsImEyKHFVKSIsIn4oQWoqKSIs
-In4ofigpKSIsImEyKGN2LHFVLHFVLEpRKSIsImM4KEApIiwifihNaD8sTWg/KSIsIkAoKSIsIn4ocVUs
-QCkiLCJ+KG42LHFVLEIyKSIsIn4ocVUscVUpIiwiYTIoa0YpIiwiYzgoQCxAKSIsIn4oeHU8cVU+KSIs
-ImM4KGVhKikiLCJiODxjOD4qKEFqKikiLCJ+KHFVLEIyKSIsIn4ocVUscVU/KSIsIm42KEAsQCkiLCJj
-OChALEd6KSIsImEyKHVIKSIsIn4oQjIsQCkiLCJ+KGVhKSIsIn4oTWhbR3o/XSkiLCJjOChNaCxHeiki
-LCJ+KHVILHVIPykiLCJ+KEAsQCkiLCJ2czxAPihAKSIsImEyKHh1PHFVPikiLCJjOCh+KCkpIiwicjco
-QCkiLCJNaD8oQCkiLCJFNChAKSIsImEyKihINyopIiwiTEwqKEApIiwiWjA8cVUqLE1oKj4qKExMKiki
-LCJAKHFVKSIsIn4oR0QsQCkiLCJjOChaMDxxVSosTWgqPiopIiwiWjA8cVUscVU+KFowPHFVLHFVPixx
-VSkiLCJxVSooQWoqKSIsIkAoQCxxVSkiLCJ+KHFVW0BdKSIsImM4KGV3KikiLCJxVSooWjA8QCxAPiop
-IiwicVUocVU/KSIsIkIyKEIyLEIyKSIsIn4oQCkiLCJNaD8oTWg/KSIsIlR6PEA+KEApIl0saW50ZXJj
-ZXB0b3JzQnlUYWc6bnVsbCxsZWFmVGFnczpudWxsLGFycmF5UnRpOnR5cGVvZiBTeW1ib2w9PSJmdW5j
-dGlvbiImJnR5cGVvZiBTeW1ib2woKT09InN5bWJvbCI/U3ltYm9sKCIkdGkiKToiJHRpIn0KSC54Yih2
-LnR5cGVVbml2ZXJzZSxKU09OLnBhcnNlKCd7ImM1IjoiTUYiLCJpQyI6Ik1GIiwia2QiOiJNRiIsInJ4
-IjoiZWEiLCJlNSI6ImVhIiwiWTAiOiJoaSIsInRwIjoiaGkiLCJHOCI6ImV3IiwiTXIiOiJxRSIsImVM
-IjoicUUiLCJJMCI6InVIIiwiaHMiOiJ1SCIsIlhnIjoiUUYiLCJuciI6IkFqIiwieTQiOiJ3NiIsImFQ
-IjoiQ20iLCJ4YyI6Im54Iiwia0oiOiJueCIsInpVIjoiRGciLCJkZiI6IkVUIiwieUUiOnsiYTIiOltd
-fSwid2UiOnsiYzgiOltdfSwiTUYiOnsidm0iOltdLCJFSCI6W119LCJqZCI6eyJ6TSI6WyIxIl0sImJR
-IjpbIjEiXSwiY1giOlsiMSJdfSwiUG8iOnsiamQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwi
-Y1giOlsiMSJdfSwibTEiOnsiQW4iOlsiMSJdfSwicUkiOnsiQ1AiOltdLCJaWiI6W119LCJiVSI6eyJD
-UCI6W10sIkIyIjpbXSwiWloiOltdfSwiVkEiOnsiQ1AiOltdLCJaWiI6W119LCJEciI6eyJxVSI6W10s
-InZYIjpbXX0sIkJSIjp7ImNYIjpbIjIiXX0sIkU3Ijp7IkFuIjpbIjIiXX0sIlp5Ijp7IkJSIjpbIjEi
-LCIyIl0sImNYIjpbIjIiXSwiY1guRSI6IjIifSwib2wiOnsiWnkiOlsiMSIsIjIiXSwiQlIiOlsiMSIs
-IjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIlVxIjp7ImxEIjpbIjIiXSwiek0i
-OlsiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNYIjpbIjIiXX0sImpWIjp7IlVxIjpbIjEi
-LCIyIl0sImxEIjpbIjIiXSwiek0iOlsiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNYIjpb
-IjIiXSwibEQuRSI6IjIiLCJjWC5FIjoiMiJ9LCJuIjp7IlhTIjpbXX0sInIzIjp7IlhTIjpbXX0sInFq
-Ijp7ImxEIjpbIkIyIl0sIlJlIjpbIkIyIl0sInpNIjpbIkIyIl0sImJRIjpbIkIyIl0sImNYIjpbIkIy
-Il0sImxELkUiOiJCMiIsIlJlLkUiOiJCMiJ9LCJHTSI6eyJYUyI6W119LCJiUSI6eyJjWCI6WyIxIl19
-LCJhTCI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIm5IIjp7ImFMIjpbIjEiXSwiYlEiOlsiMSJdLCJj
-WCI6WyIxIl0sImFMLkUiOiIxIiwiY1guRSI6IjEifSwiYTciOnsiQW4iOlsiMSJdfSwiaTEiOnsiY1gi
-OlsiMiJdLCJjWC5FIjoiMiJ9LCJ4eSI6eyJpMSI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNYIjpbIjIi
-XSwiY1guRSI6IjIifSwiTUgiOnsiQW4iOlsiMiJdfSwibEoiOnsiYUwiOlsiMiJdLCJiUSI6WyIyIl0s
-ImNYIjpbIjIiXSwiYUwuRSI6IjIiLCJjWC5FIjoiMiJ9LCJVNSI6eyJjWCI6WyIxIl0sImNYLkUiOiIx
-In0sIlNPIjp7IkFuIjpbIjEiXX0sIkFNIjp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiZDUiOnsiQU0i
-OlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwiY1guRSI6IjEifSwiVTEiOnsiQW4iOlsiMSJdfSwi
-TUIiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkZ1Ijp7IkFuIjpbIjEiXX0sInU2
-Ijp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiSkIiOnsiQW4iOlsiMSJdfSwidzIiOnsibEQiOlsiMSJd
-LCJSZSI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJ3diI6eyJHRCI6W119
-LCJQRCI6eyJHaiI6WyIxIiwiMiJdLCJSVSI6WyIxIiwiMiJdLCJQbiI6WyIxIiwiMiJdLCJLUCI6WyIx
-IiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiV1UiOnsiWjAiOlsiMSIsIjIiXX0sIkxQIjp7IldVIjpbIjEi
-LCIyIl0sIlowIjpbIjEiLCIyIl19LCJYUiI6eyJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkxJIjp7InZR
-IjpbXX0sIlcwIjp7IlhTIjpbXX0sImF6Ijp7IlhTIjpbXX0sInZWIjp7IlhTIjpbXX0sInRlIjp7IlJ6
-IjpbXX0sIlhPIjp7Ikd6IjpbXX0sIlRwIjp7IkVIIjpbXX0sImxjIjp7IkVIIjpbXX0sInp4Ijp7IkVI
-IjpbXX0sInJUIjp7IkVIIjpbXX0sIkVxIjp7IlhTIjpbXX0sImtZIjp7IlhTIjpbXX0sIk41Ijp7Illr
-IjpbIjEiLCIyIl0sIkZvIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl0sIllrLksiOiIxIiwiWWsuViI6
-IjIifSwiaTUiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIk42Ijp7IkFuIjpbIjEi
-XX0sIlZSIjp7IndMIjpbXSwidlgiOltdfSwiRUsiOnsiaWIiOltdLCJPZCI6W119LCJLVyI6eyJjWCI6
-WyJpYiJdLCJjWC5FIjoiaWIifSwiUGIiOnsiQW4iOlsiaWIiXX0sInRRIjp7Ik9kIjpbXX0sInVuIjp7
-ImNYIjpbIk9kIl0sImNYLkUiOiJPZCJ9LCJTZCI6eyJBbiI6WyJPZCJdfSwiRVQiOnsiQVMiOltdfSwi
-TFoiOnsiWGoiOlsiMSJdLCJFVCI6W10sIkFTIjpbXX0sIkRnIjp7ImxEIjpbIkNQIl0sIlhqIjpbIkNQ
-Il0sInpNIjpbIkNQIl0sIkVUIjpbXSwiYlEiOlsiQ1AiXSwiQVMiOltdLCJjWCI6WyJDUCJdLCJTVSI6
-WyJDUCJdLCJsRC5FIjoiQ1AifSwiUGciOnsibEQiOlsiQjIiXSwiWGoiOlsiQjIiXSwiek0iOlsiQjIi
-XSwiRVQiOltdLCJiUSI6WyJCMiJdLCJBUyI6W10sImNYIjpbIkIyIl0sIlNVIjpbIkIyIl19LCJ4aiI6
-eyJsRCI6WyJCMiJdLCJYaiI6WyJCMiJdLCJ6TSI6WyJCMiJdLCJFVCI6W10sImJRIjpbIkIyIl0sIkFT
-IjpbXSwiY1giOlsiQjIiXSwiU1UiOlsiQjIiXSwibEQuRSI6IkIyIn0sImRFIjp7ImxEIjpbIkIyIl0s
-IlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwiYlEiOlsiQjIiXSwiQVMiOltdLCJjWCI6WyJC
-MiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwiWkEiOnsibEQiOlsiQjIiXSwiWGoiOlsiQjIiXSwi
-ek0iOlsiQjIiXSwiRVQiOltdLCJiUSI6WyJCMiJdLCJBUyI6W10sImNYIjpbIkIyIl0sIlNVIjpbIkIy
-Il0sImxELkUiOiJCMiJ9LCJkVCI6eyJsRCI6WyJCMiJdLCJYaiI6WyJCMiJdLCJ6TSI6WyJCMiJdLCJF
-VCI6W10sImJRIjpbIkIyIl0sIkFTIjpbXSwiY1giOlsiQjIiXSwiU1UiOlsiQjIiXSwibEQuRSI6IkIy
-In0sIlBxIjp7ImxEIjpbIkIyIl0sIlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwiYlEiOlsi
-QjIiXSwiQVMiOltdLCJjWCI6WyJCMiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwiZUUiOnsibEQi
-OlsiQjIiXSwiWGoiOlsiQjIiXSwiek0iOlsiQjIiXSwiRVQiOltdLCJiUSI6WyJCMiJdLCJBUyI6W10s
-ImNYIjpbIkIyIl0sIlNVIjpbIkIyIl0sImxELkUiOiJCMiJ9LCJWNiI6eyJsRCI6WyJCMiJdLCJuNiI6
-W10sIlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwiYlEiOlsiQjIiXSwiQVMiOltdLCJjWCI6
-WyJCMiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwia1MiOnsiWFMiOltdfSwiaU0iOnsiWFMiOltd
-fSwiR1YiOnsiQW4iOlsiMSJdfSwicTQiOnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJDdyI6eyJYUyI6
-W119LCJaZiI6eyJQZiI6WyIxIl19LCJ2cyI6eyJiOCI6WyIxIl19LCJtMCI6eyJRbSI6W119LCJKaSI6
-eyJtMCI6W10sIlFtIjpbXX0sImI2Ijp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIxIl0sImNY
-IjpbIjEiXSwibGYuRSI6IjEifSwibG0iOnsiQW4iOlsiMSJdfSwibVciOnsiY1giOlsiMSJdfSwidXki
-OnsibEQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiaWwiOnsiWWsiOlsi
-MSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIllrIjp7IlowIjpbIjEiLCIyIl19LCJQbiI6eyJaMCI6WyIx
-IiwiMiJdfSwiR2oiOnsiUlUiOlsiMSIsIjIiXSwiUG4iOlsiMSIsIjIiXSwiS1AiOlsiMSIsIjIiXSwi
-WjAiOlsiMSIsIjIiXX0sIlZqIjp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpb
-IjEiXX0sIlh2Ijp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sInV3
-Ijp7IllrIjpbInFVIiwiQCJdLCJaMCI6WyJxVSIsIkAiXSwiWWsuSyI6InFVIiwiWWsuViI6IkAifSwi
-aTgiOnsiYUwiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwiYUwuRSI6InFVIiwiY1guRSI6
-InFVIn0sIkNWIjp7IlVrIjpbInpNPEIyPiIsInFVIl0sIlVrLlMiOiJ6TTxCMj4ifSwiVTgiOnsid0ki
-Olsiek08QjI+IiwicVUiXX0sIlppIjp7IlVrIjpbInFVIiwiek08QjI+Il19LCJVZCI6eyJYUyI6W119
-LCJLOCI6eyJYUyI6W119LCJieSI6eyJVayI6WyJNaD8iLCJxVSJdLCJVay5TIjoiTWg/In0sIm9qIjp7
-IndJIjpbIk1oPyIsInFVIl19LCJNeCI6eyJ3SSI6WyJxVSIsIk1oPyJdfSwidTUiOnsiVWsiOlsicVUi
-LCJ6TTxCMj4iXSwiVWsuUyI6InFVIn0sIkUzIjp7IndJIjpbInFVIiwiek08QjI+Il19LCJHWSI6eyJ3
-SSI6WyJ6TTxCMj4iLCJxVSJdfSwiQ1AiOnsiWloiOltdfSwiQjIiOnsiWloiOltdfSwiek0iOnsiYlEi
-OlsiMSJdLCJjWCI6WyIxIl19LCJpYiI6eyJPZCI6W119LCJ4dSI6eyJiUSI6WyIxIl0sImNYIjpbIjEi
-XX0sInFVIjp7InZYIjpbXX0sIkM2Ijp7IlhTIjpbXX0sIkV6Ijp7IlhTIjpbXX0sIkYiOnsiWFMiOltd
-fSwidSI6eyJYUyI6W119LCJiSiI6eyJYUyI6W119LCJlWSI6eyJYUyI6W119LCJtcCI6eyJYUyI6W119
-LCJ1YiI6eyJYUyI6W119LCJkcyI6eyJYUyI6W119LCJsaiI6eyJYUyI6W119LCJVViI6eyJYUyI6W119
-LCJrNSI6eyJYUyI6W119LCJLWSI6eyJYUyI6W119LCJjIjp7IlhTIjpbXX0sIkNEIjp7IlJ6IjpbXX0s
-ImFFIjp7IlJ6IjpbXX0sIlpkIjp7Ikd6IjpbXX0sIlJuIjp7IkJMIjpbXX0sIkRuIjp7ImlEIjpbXX0s
-IlVmIjp7ImlEIjpbXX0sInFlIjp7ImlEIjpbXX0sInFFIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119
-LCJHaCI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiZlkiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpb
-XX0sIm5CIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJRUCI6eyJjdiI6W10sInVIIjpbXSwiRDAi
-OltdfSwibngiOnsidUgiOltdLCJEMCI6W119LCJRRiI6eyJ1SCI6W10sIkQwIjpbXX0sIklCIjp7InRu
-IjpbIlpaIl19LCJ3eiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0s
-ImxELkUiOiIxIn0sImN2Ijp7InVIIjpbXSwiRDAiOltdfSwiaEgiOnsiQXoiOltdfSwiaDQiOnsiY3Yi
-OltdLCJ1SCI6W10sIkQwIjpbXX0sIlZiIjp7InVIIjpbXSwiRDAiOltdfSwiZkoiOnsiRDAiOltdfSwi
-d2EiOnsiRDAiOltdfSwiQWoiOnsiZWEiOltdfSwiZTciOnsibEQiOlsidUgiXSwiek0iOlsidUgiXSwi
-YlEiOlsidUgiXSwiY1giOlsidUgiXSwibEQuRSI6InVIIn0sInVIIjp7IkQwIjpbXX0sIkJIIjp7ImxE
-IjpbInVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJRIjpbInVIIl0sImNY
-IjpbInVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJTTiI6eyJjdiI6W10sInVIIjpbXSwiRDAi
-OltdfSwiZXciOnsiZWEiOltdfSwibHAiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlRiIjp7ImN2
-IjpbXSwidUgiOltdLCJEMCI6W119LCJJdiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiV1AiOnsi
-Y3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sInlZIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJ3NiI6
-eyJlYSI6W119LCJLNSI6eyJ2NiI6W10sIkQwIjpbXX0sIkNtIjp7IkQwIjpbXX0sIkNRIjp7InVIIjpb
-XSwiRDAiOltdfSwidzQiOnsidG4iOlsiWloiXX0sInJoIjp7ImxEIjpbInVIIl0sIkdtIjpbInVIIl0s
-InpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJRIjpbInVIIl0sImNYIjpbInVIIl0sImxELkUiOiJ1SCIs
-IkdtLkUiOiJ1SCJ9LCJjZiI6eyJZayI6WyJxVSIsInFVIl0sIlowIjpbInFVIiwicVUiXX0sImk3Ijp7
-IllrIjpbInFVIiwicVUiXSwiWjAiOlsicVUiLCJxVSJdLCJZay5LIjoicVUiLCJZay5WIjoicVUifSwi
-U3kiOnsiWWsiOlsicVUiLCJxVSJdLCJaMCI6WyJxVSIsInFVIl0sIllrLksiOiJxVSIsIllrLlYiOiJx
-VSJ9LCJJNCI6eyJsZiI6WyJxVSJdLCJ4dSI6WyJxVSJdLCJiUSI6WyJxVSJdLCJjWCI6WyJxVSJdLCJs
-Zi5FIjoicVUifSwiUk8iOnsicWgiOlsiMSJdfSwiZXUiOnsiUk8iOlsiMSJdLCJxaCI6WyIxIl19LCJ4
-QyI6eyJNTyI6WyIxIl19LCJKUSI6eyJrRiI6W119LCJ2RCI6eyJrRiI6W119LCJtNiI6eyJrRiI6W119
-LCJjdCI6eyJrRiI6W119LCJPdyI6eyJrRiI6W119LCJXOSI6eyJBbiI6WyIxIl19LCJkVyI6eyJ2NiI6
-W10sIkQwIjpbXX0sIm1rIjp7InkwIjpbXX0sIktvIjp7Im9uIjpbXX0sIkFzIjp7ImxmIjpbInFVIl0s
-Inh1IjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFVIl19LCJyNyI6eyJFNCI6W119LCJUeiI6eyJs
-RCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJFNCI6W10sImNYIjpbIjEiXSwibEQuRSI6IjEi
-fSwibmQiOnsiaGkiOltdLCJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiS2UiOnsibGYiOlsicVUiXSwi
-eHUiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwibGYuRSI6InFVIn0sImhpIjp7ImN2Ijpb
-XSwidUgiOltdLCJEMCI6W119LCJYQSI6eyJrRiI6W119LCJ2dCI6eyJEOCI6W119LCJjRCI6eyJEOCI6
-W119LCJkdiI6eyJSeiI6W119LCJPRiI6eyJmdiI6W119LCJydSI6eyJmdiI6W119LCJJViI6eyJmdiI6
-W119LCJuNiI6eyJ6TSI6WyJCMiJdLCJiUSI6WyJCMiJdLCJjWCI6WyJCMiJdLCJBUyI6W119fScpKQpI
-LkZGKHYudHlwZVVuaXZlcnNlLEpTT04ucGFyc2UoJ3sidzIiOjEsIlFDIjoyLCJMWiI6MSwia1QiOjIs
-Im1XIjoxLCJ1eSI6MSwiaWwiOjIsIlZqIjoxLCJYdiI6MSwiblkiOjEsIldZIjoxLCJwUiI6MSwiY28i
-OjF9JykpCnZhciB1PXtsOiJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEgVVJJIHdpdGgg
-YSBmcmFnbWVudCBjb21wb25lbnQiLGk6IkNhbm5vdCBleHRyYWN0IGEgZmlsZSBwYXRoIGZyb20gYSBV
-Ukkgd2l0aCBhIHF1ZXJ5IGNvbXBvbmVudCIsajoiQ2Fubm90IGV4dHJhY3QgYSBub24tV2luZG93cyBm
-aWxlIHBhdGggZnJvbSBhIGZpbGUgVVJJIHdpdGggYW4gYXV0aG9yaXR5IixnOiJgbnVsbGAgZW5jb3Vu
-dGVyZWQgYXMgdGhlIHJlc3VsdCBmcm9tIGV4cHJlc3Npb24gd2l0aCB0eXBlIGBOZXZlcmAuIixkOiJh
-cmVhLWFuYWx5emVyLGFuYWx5emVyLW5uYmQtbWlncmF0aW9uLHR5cGUtYnVnIn0KdmFyIHQ9KGZ1bmN0
-aW9uIHJ0aWkoKXt2YXIgcz1ILk4wCnJldHVybntuOnMoIkN3IiksY1I6cygibkIiKSx3OnMoIkF6Iiks
-cDpzKCJRUCIpLGdGOnMoIlBEPEdELEA+IiksZDpzKCJiUTxAPiIpLGg6cygiY3YiKSxyOnMoIlhTIiks
-QjpzKCJlYSIpLGFTOnMoIkQwIiksZzg6cygiUnoiKSxjODpzKCJoSCIpLFk6cygiRUgiKSxlOnMoImI4
-PEA+IiksSTpzKCJTZyIpLG86cygidlEiKSxlaDpzKCJjWDx1SD4iKSxROnMoImNYPHFVPiIpLHU6cygi
-Y1g8QD4iKSx2OnMoImpkPGtGPiIpLHM6cygiamQ8cVU+IiksZ046cygiamQ8bjY+IiksYjpzKCJqZDxA
-PiIpLGE6cygiamQ8QjI+IiksZDc6cygiamQ8U2UqPiIpLGg0OnMoImpkPGo4Kj4iKSxHOnMoImpkPFow
-PHFVKixNaCo+Kj4iKSxjUTpzKCJqZDxEOCo+IiksaTpzKCJqZDxxVSo+IiksYUE6cygiamQ8eUQqPiIp
-LGFKOnMoImpkPHdiKj4iKSxWOnMoImpkPEIyKj4iKSxkNDpzKCJqZDxxVT8+IiksVDpzKCJ3ZSIpLGVI
-OnMoInZtIikseDpzKCJjNSIpLGFVOnMoIlhqPEA+IiksYW06cygiVHo8QD4iKSxlbzpzKCJONTxHRCxA
-PiIpLGR6OnMoImhGIiksRDpzKCJ6TTxxVT4iKSxqOnMoInpNPEA+IiksTDpzKCJ6TTxCMj4iKSxKOnMo
-IlowPHFVLHFVPiIpLGY6cygiWjA8QCxAPiIpLGRvOnMoImxKPHFVLEA+IiksZmo6cygibEo8cVUqLHFV
-PiIpLGRFOnMoIkVUIiksYm06cygiVjYiKSxBOnMoInVIIiksRTpzKCJrRiIpLFA6cygiYzgiKSxLOnMo
-Ik1oIikscTpzKCJ0bjxaWj4iKSxmdjpzKCJ3TCIpLGV3OnMoIm5kIiksQzpzKCJ4dTxxVT4iKSxsOnMo
-Ikd6IiksTjpzKCJxVSIpLGQwOnMoInFVKHFVKikiKSxnNzpzKCJoaSIpLGZvOnMoIkdEIiksYVc6cygi
-eVkiKSxhazpzKCJBUyIpLGdjOnMoIm42IiksYko6cygia2QiKSxkdzpzKCJHajxxVSxxVT4iKSxkRDpz
-KCJpRCIpLGVKOnMoInU2PHFVPiIpLGc0OnMoIks1IiksY2k6cygidjYiKSxnMjpzKCJDbSIpLGJDOnMo
-IlpmPGZKKj4iKSxoOTpzKCJDUSIpLGFjOnMoImU3IiksazpzKCJldTxBaio+IiksUjpzKCJ3ejxjdio+
-IiksYzpzKCJ2czxAPiIpLGZKOnMoInZzPEIyPiIpLGdWOnMoInZzPGZKKj4iKSxjcjpzKCJKUSIpLHk6
-cygiYTIiKSxhbDpzKCJhMihNaCkiKSxnUjpzKCJDUCIpLHo6cygiQCIpLGZPOnMoIkAoKSIpLGJJOnMo
-IkAoTWgpIiksYWc6cygiQChNaCxHeikiKSxiVTpzKCJAKHh1PHFVPikiKSxkTzpzKCJAKHFVKSIpLGI4
-OnMoIkAoQCxAKSIpLFM6cygiQjIiKSxkZDpzKCJHaCoiKSxnOnMoImN2KiIpLGFMOnMoImVhKiIpLGFY
-OnMoIkxMKiIpLGZFOnMoIkg3KiIpLFU6cygiY1g8QD4qIiksZEg6cygiRTQqIiksZks6cygiek08QD4q
-IiksZF86cygiek08ajgqPioiKSxkcDpzKCJ6TTxaMDxxVSosTWgqPio+KiIpLGVFOnMoInpNPE1oKj4q
-IiksYXc6cygiWjA8QCxAPioiKSx0OnMoIlowPHFVKixNaCo+KiIpLE86cygiQWoqIiksY0Y6cygiMCYq
-IiksXzpzKCJNaCoiKSxlUTpzKCJldyoiKSxYOnMoInFVKiIpLGNoOnMoIkQwPyIpLGJHOnMoImI4PGM4
-Pj8iKSxiazpzKCJ6TTxxVT4/IiksYk06cygiek08QD4/IiksY1o6cygiWjA8cVUscVU+PyIpLGM5OnMo
-IlowPHFVLEA+PyIpLFc6cygiTWg/IiksRjpzKCJGZTxALEA+PyIpLG06cygiYm4/IiksYjc6cygiYTIo
-TWgpPyIpLGJ3OnMoIkAoZWEpPyIpLGZWOnMoIk1oPyhNaD8sTWg/KT8iKSxkQTpzKCJNaD8oQCk/Iiks
-WjpzKCJ+KCk/IiksZWI6cygifihldyopPyIpLGRpOnMoIlpaIiksSDpzKCJ+IiksTTpzKCJ+KCkiKSxl
-QTpzKCJ+KHFVLHFVKSIpLGNBOnMoIn4ocVUsQCkiKX19KSgpOyhmdW5jdGlvbiBjb25zdGFudHMoKXt2
-YXIgcz1odW5rSGVscGVycy5tYWtlQ29uc3RMaXN0CkMueG49Vy5HaC5wcm90b3R5cGUKQy5SWT1XLlFQ
-LnByb3RvdHlwZQpDLm1IPVcuYWUucHJvdG90eXBlCkMuQlo9Vy5WYi5wcm90b3R5cGUKQy5EdD1XLmZK
-LnByb3RvdHlwZQpDLk9rPUouR3YucHJvdG90eXBlCkMuTm09Si5qZC5wcm90b3R5cGUKQy5qbj1KLmJV
-LnByb3RvdHlwZQpDLmpOPUoud2UucHJvdG90eXBlCkMuQ0Q9Si5xSS5wcm90b3R5cGUKQy54Qj1KLkRy
-LnByb3RvdHlwZQpDLkRHPUouYzUucHJvdG90eXBlCkMuRXg9Vy53Ny5wcm90b3R5cGUKQy5OQT1ILlY2
-LnByb3RvdHlwZQpDLnQ1PVcuQkgucHJvdG90eXBlCkMuTHQ9Vy5TTi5wcm90b3R5cGUKQy5aUT1KLmlD
-LnByb3RvdHlwZQpDLkllPVcuVGIucHJvdG90eXBlCkMudkI9Si5rZC5wcm90b3R5cGUKQy5vbD1XLks1
-LnByb3RvdHlwZQpDLnk4PW5ldyBQLlU4KCkKQy5oOT1uZXcgUC5DVigpCkMuR3c9bmV3IEguRnUoSC5O
-MCgiRnU8Yzg+IikpCkMuTzQ9ZnVuY3Rpb24gZ2V0VGFnRmFsbGJhY2sobykgewogIHZhciBzID0gT2Jq
-ZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKG8pOwogIHJldHVybiBzLnN1YnN0cmluZyg4LCBzLmxl
-bmd0aCAtIDEpOwp9CkMuWXE9ZnVuY3Rpb24oKSB7CiAgdmFyIHRvU3RyaW5nRnVuY3Rpb24gPSBPYmpl
-Y3QucHJvdG90eXBlLnRvU3RyaW5nOwogIGZ1bmN0aW9uIGdldFRhZyhvKSB7CiAgICB2YXIgcyA9IHRv
-U3RyaW5nRnVuY3Rpb24uY2FsbChvKTsKICAgIHJldHVybiBzLnN1YnN0cmluZyg4LCBzLmxlbmd0aCAt
-IDEpOwogIH0KICBmdW5jdGlvbiBnZXRVbmtub3duVGFnKG9iamVjdCwgdGFnKSB7CiAgICBpZiAoL15I
-VE1MW0EtWl0uKkVsZW1lbnQkLy50ZXN0KHRhZykpIHsKICAgICAgdmFyIG5hbWUgPSB0b1N0cmluZ0Z1
-bmN0aW9uLmNhbGwob2JqZWN0KTsKICAgICAgaWYgKG5hbWUgPT0gIltvYmplY3QgT2JqZWN0XSIpIHJl
-dHVybiBudWxsOwogICAgICByZXR1cm4gIkhUTUxFbGVtZW50IjsKICAgIH0KICB9CiAgZnVuY3Rpb24g
-Z2V0VW5rbm93blRhZ0dlbmVyaWNCcm93c2VyKG9iamVjdCwgdGFnKSB7CiAgICBpZiAoc2VsZi5IVE1M
-RWxlbWVudCAmJiBvYmplY3QgaW5zdGFuY2VvZiBIVE1MRWxlbWVudCkgcmV0dXJuICJIVE1MRWxlbWVu
-dCI7CiAgICByZXR1cm4gZ2V0VW5rbm93blRhZyhvYmplY3QsIHRhZyk7CiAgfQogIGZ1bmN0aW9uIHBy
-b3RvdHlwZUZvclRhZyh0YWcpIHsKICAgIGlmICh0eXBlb2Ygd2luZG93ID09ICJ1bmRlZmluZWQiKSBy
-ZXR1cm4gbnVsbDsKICAgIGlmICh0eXBlb2Ygd2luZG93W3RhZ10gPT0gInVuZGVmaW5lZCIpIHJldHVy
-biBudWxsOwogICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBpZiAodHlwZW9mIGNv
-bnN0cnVjdG9yICE9ICJmdW5jdGlvbiIpIHJldHVybiBudWxsOwogICAgcmV0dXJuIGNvbnN0cnVjdG9y
-LnByb3RvdHlwZTsKICB9CiAgZnVuY3Rpb24gZGlzY3JpbWluYXRvcih0YWcpIHsgcmV0dXJuIG51bGw7
-IH0KICB2YXIgaXNCcm93c2VyID0gdHlwZW9mIG5hdmlnYXRvciA9PSAib2JqZWN0IjsKICByZXR1cm4g
-ewogICAgZ2V0VGFnOiBnZXRUYWcsCiAgICBnZXRVbmtub3duVGFnOiBpc0Jyb3dzZXIgPyBnZXRVbmtu
-b3duVGFnR2VuZXJpY0Jyb3dzZXIgOiBnZXRVbmtub3duVGFnLAogICAgcHJvdG90eXBlRm9yVGFnOiBw
-cm90b3R5cGVGb3JUYWcsCiAgICBkaXNjcmltaW5hdG9yOiBkaXNjcmltaW5hdG9yIH07Cn0KQy53Yj1m
-dW5jdGlvbihnZXRUYWdGYWxsYmFjaykgewogIHJldHVybiBmdW5jdGlvbihob29rcykgewogICAgaWYg
-KHR5cGVvZiBuYXZpZ2F0b3IgIT0gIm9iamVjdCIpIHJldHVybiBob29rczsKICAgIHZhciB1YSA9IG5h
-dmlnYXRvci51c2VyQWdlbnQ7CiAgICBpZiAodWEuaW5kZXhPZigiRHVtcFJlbmRlclRyZWUiKSA+PSAw
-KSByZXR1cm4gaG9va3M7CiAgICBpZiAodWEuaW5kZXhPZigiQ2hyb21lIikgPj0gMCkgewogICAgICBm
-dW5jdGlvbiBjb25maXJtKHApIHsKICAgICAgICByZXR1cm4gdHlwZW9mIHdpbmRvdyA9PSAib2JqZWN0
-IiAmJiB3aW5kb3dbcF0gJiYgd2luZG93W3BdLm5hbWUgPT0gcDsKICAgICAgfQogICAgICBpZiAoY29u
-ZmlybSgiV2luZG93IikgJiYgY29uZmlybSgiSFRNTEVsZW1lbnQiKSkgcmV0dXJuIGhvb2tzOwogICAg
-fQogICAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRmFsbGJhY2s7CiAgfTsKfQpDLktVPWZ1bmN0aW9uKGhv
-b2tzKSB7CiAgaWYgKHR5cGVvZiBkYXJ0RXhwZXJpbWVudGFsRml4dXBHZXRUYWcgIT0gImZ1bmN0aW9u
-IikgcmV0dXJuIGhvb2tzOwogIGhvb2tzLmdldFRhZyA9IGRhcnRFeHBlcmltZW50YWxGaXh1cEdldFRh
-Zyhob29rcy5nZXRUYWcpOwp9CkMuZlE9ZnVuY3Rpb24oaG9va3MpIHsKICB2YXIgZ2V0VGFnID0gaG9v
-a3MuZ2V0VGFnOwogIHZhciBwcm90b3R5cGVGb3JUYWcgPSBob29rcy5wcm90b3R5cGVGb3JUYWc7CiAg
-ZnVuY3Rpb24gZ2V0VGFnRml4ZWQobykgewogICAgdmFyIHRhZyA9IGdldFRhZyhvKTsKICAgIGlmICh0
-YWcgPT0gIkRvY3VtZW50IikgewogICAgICBpZiAoISFvLnhtbFZlcnNpb24pIHJldHVybiAiIURvY3Vt
-ZW50IjsKICAgICAgcmV0dXJuICIhSFRNTERvY3VtZW50IjsKICAgIH0KICAgIHJldHVybiB0YWc7CiAg
-fQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0ZpeGVkKHRhZykgewogICAgaWYgKHRhZyA9PSAiRG9j
-dW1lbnQiKSByZXR1cm4gbnVsbDsKICAgIHJldHVybiBwcm90b3R5cGVGb3JUYWcodGFnKTsKICB9CiAg
-aG9va3MuZ2V0VGFnID0gZ2V0VGFnRml4ZWQ7CiAgaG9va3MucHJvdG90eXBlRm9yVGFnID0gcHJvdG90
-eXBlRm9yVGFnRml4ZWQ7Cn0KQy5kaz1mdW5jdGlvbihob29rcykgewogIHZhciB1c2VyQWdlbnQgPSB0
-eXBlb2YgbmF2aWdhdG9yID09ICJvYmplY3QiID8gbmF2aWdhdG9yLnVzZXJBZ2VudCA6ICIiOwogIGlm
-ICh1c2VyQWdlbnQuaW5kZXhPZigiRmlyZWZveCIpID09IC0xKSByZXR1cm4gaG9va3M7CiAgdmFyIGdl
-dFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAgICAiQmVmb3JlVW5sb2FkRXZl
-bnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9hcmQiLAogICAgIkdlb0dlb2xv
-Y2F0aW9uIjogIkdlb2xvY2F0aW9uIiwKICAgICJMb2NhdGlvbiI6ICIhTG9jYXRpb24iLAogICAgIldv
-cmtlck1lc3NhZ2VFdmVudCI6ICJNZXNzYWdlRXZlbnQiLAogICAgIlhNTERvY3VtZW50IjogIiFEb2N1
-bWVudCJ9OwogIGZ1bmN0aW9uIGdldFRhZ0ZpcmVmb3gobykgewogICAgdmFyIHRhZyA9IGdldFRhZyhv
-KTsKICAgIHJldHVybiBxdWlja01hcFt0YWddIHx8IHRhZzsKICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0
-VGFnRmlyZWZveDsKfQpDLnhpPWZ1bmN0aW9uKGhvb2tzKSB7CiAgdmFyIHVzZXJBZ2VudCA9IHR5cGVv
-ZiBuYXZpZ2F0b3IgPT0gIm9iamVjdCIgPyBuYXZpZ2F0b3IudXNlckFnZW50IDogIiI7CiAgaWYgKHVz
-ZXJBZ2VudC5pbmRleE9mKCJUcmlkZW50LyIpID09IC0xKSByZXR1cm4gaG9va3M7CiAgdmFyIGdldFRh
-ZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAgICAiQmVmb3JlVW5sb2FkRXZlbnQi
-OiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9hcmQiLAogICAgIkhUTUxEREVsZW1l
-bnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIkhUTUxEVEVsZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAg
-IkhUTUxQaHJhc2VFbGVtZW50IjogIkhUTUxFbGVtZW50IiwKICAgICJQb3NpdGlvbiI6ICJHZW9wb3Np
-dGlvbiIKICB9OwogIGZ1bmN0aW9uIGdldFRhZ0lFKG8pIHsKICAgIHZhciB0YWcgPSBnZXRUYWcobyk7
-CiAgICB2YXIgbmV3VGFnID0gcXVpY2tNYXBbdGFnXTsKICAgIGlmIChuZXdUYWcpIHJldHVybiBuZXdU
-YWc7CiAgICBpZiAodGFnID09ICJPYmplY3QiKSB7CiAgICAgIGlmICh3aW5kb3cuRGF0YVZpZXcgJiYg
-KG8gaW5zdGFuY2VvZiB3aW5kb3cuRGF0YVZpZXcpKSByZXR1cm4gIkRhdGFWaWV3IjsKICAgIH0KICAg
-IHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0lFKHRhZykgewogICAgdmFy
-IGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBpZiAoY29uc3RydWN0b3IgPT0gbnVsbCkgcmV0
-dXJuIG51bGw7CiAgICByZXR1cm4gY29uc3RydWN0b3IucHJvdG90eXBlOwogIH0KICBob29rcy5nZXRU
-YWcgPSBnZXRUYWdJRTsKICBob29rcy5wcm90b3R5cGVGb3JUYWcgPSBwcm90b3R5cGVGb3JUYWdJRTsK
-fQpDLmk3PWZ1bmN0aW9uKGhvb2tzKSB7IHJldHVybiBob29rczsgfQoKQy5DdD1uZXcgUC5ieSgpCkMu
-RXE9bmV3IFAuazUoKQpDLnhNPW5ldyBQLnU1KCkKQy5Raz1uZXcgUC5FMygpCkMuTnY9bmV3IEgua3Io
-KQpDLk5VPW5ldyBQLkppKCkKQy5wZD1uZXcgUC5aZCgpCkMuQWQ9bmV3IE0uSDcoMCwiSGludEFjdGlv
-bktpbmQuYWRkTnVsbGFibGVIaW50IikKQy5uZT1uZXcgTS5INygxLCJIaW50QWN0aW9uS2luZC5hZGRO
-b25OdWxsYWJsZUhpbnQiKQpDLm15PW5ldyBNLkg3KDIsIkhpbnRBY3Rpb25LaW5kLmNoYW5nZVRvTnVs
-bGFibGVIaW50IikKQy5yeD1uZXcgTS5INygzLCJIaW50QWN0aW9uS2luZC5jaGFuZ2VUb05vbk51bGxh
-YmxlSGludCIpCkMud1Y9bmV3IE0uSDcoNCwiSGludEFjdGlvbktpbmQucmVtb3ZlTnVsbGFibGVIaW50
-IikKQy5mUj1uZXcgTS5INyg1LCJIaW50QWN0aW9uS2luZC5yZW1vdmVOb25OdWxsYWJsZUhpbnQiKQpD
-LkEzPW5ldyBQLk14KG51bGwpCkMublg9bmV3IFAub2oobnVsbCkKQy5jdz1uZXcgTC5HYigwLCJVbml0
-TWlncmF0aW9uU3RhdHVzLmFscmVhZHlNaWdyYXRlZCIpCkMuZGM9bmV3IEwuR2IoMSwiVW5pdE1pZ3Jh
-dGlvblN0YXR1cy5pbmRldGVybWluYXRlIikKQy5XRD1uZXcgTC5HYigyLCJVbml0TWlncmF0aW9uU3Rh
-dHVzLm1pZ3JhdGluZyIpCkMuWGo9bmV3IEwuR2IoMywiVW5pdE1pZ3JhdGlvblN0YXR1cy5vcHRpbmdP
-dXQiKQpDLmwwPUguVk0ocyhbQy5jdyxDLmRjLEMuV0QsQy5Yal0pLEguTjAoImpkPEdiKj4iKSkKQy5h
-az1ILlZNKHMoWzAsMCwzMjc3NiwzMzc5MiwxLDEwMjQwLDAsMF0pLHQuVikKQy5jbT1ILlZNKHMoWyIq
-OjpjbGFzcyIsIio6OmRpciIsIio6OmRyYWdnYWJsZSIsIio6OmhpZGRlbiIsIio6OmlkIiwiKjo6aW5l
-cnQiLCIqOjppdGVtcHJvcCIsIio6Oml0ZW1yZWYiLCIqOjppdGVtc2NvcGUiLCIqOjpsYW5nIiwiKjo6
-c3BlbGxjaGVjayIsIio6OnRpdGxlIiwiKjo6dHJhbnNsYXRlIiwiQTo6YWNjZXNza2V5IiwiQTo6Y29v
-cmRzIiwiQTo6aHJlZmxhbmciLCJBOjpuYW1lIiwiQTo6c2hhcGUiLCJBOjp0YWJpbmRleCIsIkE6OnRh
-cmdldCIsIkE6OnR5cGUiLCJBUkVBOjphY2Nlc3NrZXkiLCJBUkVBOjphbHQiLCJBUkVBOjpjb29yZHMi
-LCJBUkVBOjpub2hyZWYiLCJBUkVBOjpzaGFwZSIsIkFSRUE6OnRhYmluZGV4IiwiQVJFQTo6dGFyZ2V0
-IiwiQVVESU86OmNvbnRyb2xzIiwiQVVESU86Omxvb3AiLCJBVURJTzo6bWVkaWFncm91cCIsIkFVRElP
-OjptdXRlZCIsIkFVRElPOjpwcmVsb2FkIiwiQkRPOjpkaXIiLCJCT0RZOjphbGluayIsIkJPRFk6OmJn
-Y29sb3IiLCJCT0RZOjpsaW5rIiwiQk9EWTo6dGV4dCIsIkJPRFk6OnZsaW5rIiwiQlI6OmNsZWFyIiwi
-QlVUVE9OOjphY2Nlc3NrZXkiLCJCVVRUT046OmRpc2FibGVkIiwiQlVUVE9OOjpuYW1lIiwiQlVUVE9O
-Ojp0YWJpbmRleCIsIkJVVFRPTjo6dHlwZSIsIkJVVFRPTjo6dmFsdWUiLCJDQU5WQVM6OmhlaWdodCIs
-IkNBTlZBUzo6d2lkdGgiLCJDQVBUSU9OOjphbGlnbiIsIkNPTDo6YWxpZ24iLCJDT0w6OmNoYXIiLCJD
-T0w6OmNoYXJvZmYiLCJDT0w6OnNwYW4iLCJDT0w6OnZhbGlnbiIsIkNPTDo6d2lkdGgiLCJDT0xHUk9V
-UDo6YWxpZ24iLCJDT0xHUk9VUDo6Y2hhciIsIkNPTEdST1VQOjpjaGFyb2ZmIiwiQ09MR1JPVVA6OnNw
-YW4iLCJDT0xHUk9VUDo6dmFsaWduIiwiQ09MR1JPVVA6OndpZHRoIiwiQ09NTUFORDo6Y2hlY2tlZCIs
-IkNPTU1BTkQ6OmNvbW1hbmQiLCJDT01NQU5EOjpkaXNhYmxlZCIsIkNPTU1BTkQ6OmxhYmVsIiwiQ09N
-TUFORDo6cmFkaW9ncm91cCIsIkNPTU1BTkQ6OnR5cGUiLCJEQVRBOjp2YWx1ZSIsIkRFTDo6ZGF0ZXRp
-bWUiLCJERVRBSUxTOjpvcGVuIiwiRElSOjpjb21wYWN0IiwiRElWOjphbGlnbiIsIkRMOjpjb21wYWN0
-IiwiRklFTERTRVQ6OmRpc2FibGVkIiwiRk9OVDo6Y29sb3IiLCJGT05UOjpmYWNlIiwiRk9OVDo6c2l6
-ZSIsIkZPUk06OmFjY2VwdCIsIkZPUk06OmF1dG9jb21wbGV0ZSIsIkZPUk06OmVuY3R5cGUiLCJGT1JN
-OjptZXRob2QiLCJGT1JNOjpuYW1lIiwiRk9STTo6bm92YWxpZGF0ZSIsIkZPUk06OnRhcmdldCIsIkZS
-QU1FOjpuYW1lIiwiSDE6OmFsaWduIiwiSDI6OmFsaWduIiwiSDM6OmFsaWduIiwiSDQ6OmFsaWduIiwi
-SDU6OmFsaWduIiwiSDY6OmFsaWduIiwiSFI6OmFsaWduIiwiSFI6Om5vc2hhZGUiLCJIUjo6c2l6ZSIs
-IkhSOjp3aWR0aCIsIkhUTUw6OnZlcnNpb24iLCJJRlJBTUU6OmFsaWduIiwiSUZSQU1FOjpmcmFtZWJv
-cmRlciIsIklGUkFNRTo6aGVpZ2h0IiwiSUZSQU1FOjptYXJnaW5oZWlnaHQiLCJJRlJBTUU6Om1hcmdp
-bndpZHRoIiwiSUZSQU1FOjp3aWR0aCIsIklNRzo6YWxpZ24iLCJJTUc6OmFsdCIsIklNRzo6Ym9yZGVy
-IiwiSU1HOjpoZWlnaHQiLCJJTUc6OmhzcGFjZSIsIklNRzo6aXNtYXAiLCJJTUc6Om5hbWUiLCJJTUc6
-OnVzZW1hcCIsIklNRzo6dnNwYWNlIiwiSU1HOjp3aWR0aCIsIklOUFVUOjphY2NlcHQiLCJJTlBVVDo6
-YWNjZXNza2V5IiwiSU5QVVQ6OmFsaWduIiwiSU5QVVQ6OmFsdCIsIklOUFVUOjphdXRvY29tcGxldGUi
-LCJJTlBVVDo6YXV0b2ZvY3VzIiwiSU5QVVQ6OmNoZWNrZWQiLCJJTlBVVDo6ZGlzYWJsZWQiLCJJTlBV
-VDo6aW5wdXRtb2RlIiwiSU5QVVQ6OmlzbWFwIiwiSU5QVVQ6Omxpc3QiLCJJTlBVVDo6bWF4IiwiSU5Q
-VVQ6Om1heGxlbmd0aCIsIklOUFVUOjptaW4iLCJJTlBVVDo6bXVsdGlwbGUiLCJJTlBVVDo6bmFtZSIs
-IklOUFVUOjpwbGFjZWhvbGRlciIsIklOUFVUOjpyZWFkb25seSIsIklOUFVUOjpyZXF1aXJlZCIsIklO
-UFVUOjpzaXplIiwiSU5QVVQ6OnN0ZXAiLCJJTlBVVDo6dGFiaW5kZXgiLCJJTlBVVDo6dHlwZSIsIklO
-UFVUOjp1c2VtYXAiLCJJTlBVVDo6dmFsdWUiLCJJTlM6OmRhdGV0aW1lIiwiS0VZR0VOOjpkaXNhYmxl
-ZCIsIktFWUdFTjo6a2V5dHlwZSIsIktFWUdFTjo6bmFtZSIsIkxBQkVMOjphY2Nlc3NrZXkiLCJMQUJF
-TDo6Zm9yIiwiTEVHRU5EOjphY2Nlc3NrZXkiLCJMRUdFTkQ6OmFsaWduIiwiTEk6OnR5cGUiLCJMSTo6
-dmFsdWUiLCJMSU5LOjpzaXplcyIsIk1BUDo6bmFtZSIsIk1FTlU6OmNvbXBhY3QiLCJNRU5VOjpsYWJl
-bCIsIk1FTlU6OnR5cGUiLCJNRVRFUjo6aGlnaCIsIk1FVEVSOjpsb3ciLCJNRVRFUjo6bWF4IiwiTUVU
-RVI6Om1pbiIsIk1FVEVSOjp2YWx1ZSIsIk9CSkVDVDo6dHlwZW11c3RtYXRjaCIsIk9MOjpjb21wYWN0
-IiwiT0w6OnJldmVyc2VkIiwiT0w6OnN0YXJ0IiwiT0w6OnR5cGUiLCJPUFRHUk9VUDo6ZGlzYWJsZWQi
-LCJPUFRHUk9VUDo6bGFiZWwiLCJPUFRJT046OmRpc2FibGVkIiwiT1BUSU9OOjpsYWJlbCIsIk9QVElP
-Tjo6c2VsZWN0ZWQiLCJPUFRJT046OnZhbHVlIiwiT1VUUFVUOjpmb3IiLCJPVVRQVVQ6Om5hbWUiLCJQ
-OjphbGlnbiIsIlBSRTo6d2lkdGgiLCJQUk9HUkVTUzo6bWF4IiwiUFJPR1JFU1M6Om1pbiIsIlBST0dS
-RVNTOjp2YWx1ZSIsIlNFTEVDVDo6YXV0b2NvbXBsZXRlIiwiU0VMRUNUOjpkaXNhYmxlZCIsIlNFTEVD
-VDo6bXVsdGlwbGUiLCJTRUxFQ1Q6Om5hbWUiLCJTRUxFQ1Q6OnJlcXVpcmVkIiwiU0VMRUNUOjpzaXpl
-IiwiU0VMRUNUOjp0YWJpbmRleCIsIlNPVVJDRTo6dHlwZSIsIlRBQkxFOjphbGlnbiIsIlRBQkxFOjpi
-Z2NvbG9yIiwiVEFCTEU6OmJvcmRlciIsIlRBQkxFOjpjZWxscGFkZGluZyIsIlRBQkxFOjpjZWxsc3Bh
-Y2luZyIsIlRBQkxFOjpmcmFtZSIsIlRBQkxFOjpydWxlcyIsIlRBQkxFOjpzdW1tYXJ5IiwiVEFCTEU6
-OndpZHRoIiwiVEJPRFk6OmFsaWduIiwiVEJPRFk6OmNoYXIiLCJUQk9EWTo6Y2hhcm9mZiIsIlRCT0RZ
-Ojp2YWxpZ24iLCJURDo6YWJiciIsIlREOjphbGlnbiIsIlREOjpheGlzIiwiVEQ6OmJnY29sb3IiLCJU
-RDo6Y2hhciIsIlREOjpjaGFyb2ZmIiwiVEQ6OmNvbHNwYW4iLCJURDo6aGVhZGVycyIsIlREOjpoZWln
-aHQiLCJURDo6bm93cmFwIiwiVEQ6OnJvd3NwYW4iLCJURDo6c2NvcGUiLCJURDo6dmFsaWduIiwiVEQ6
-OndpZHRoIiwiVEVYVEFSRUE6OmFjY2Vzc2tleSIsIlRFWFRBUkVBOjphdXRvY29tcGxldGUiLCJURVhU
-QVJFQTo6Y29scyIsIlRFWFRBUkVBOjpkaXNhYmxlZCIsIlRFWFRBUkVBOjppbnB1dG1vZGUiLCJURVhU
-QVJFQTo6bmFtZSIsIlRFWFRBUkVBOjpwbGFjZWhvbGRlciIsIlRFWFRBUkVBOjpyZWFkb25seSIsIlRF
-WFRBUkVBOjpyZXF1aXJlZCIsIlRFWFRBUkVBOjpyb3dzIiwiVEVYVEFSRUE6OnRhYmluZGV4IiwiVEVY
-VEFSRUE6OndyYXAiLCJURk9PVDo6YWxpZ24iLCJURk9PVDo6Y2hhciIsIlRGT09UOjpjaGFyb2ZmIiwi
-VEZPT1Q6OnZhbGlnbiIsIlRIOjphYmJyIiwiVEg6OmFsaWduIiwiVEg6OmF4aXMiLCJUSDo6Ymdjb2xv
-ciIsIlRIOjpjaGFyIiwiVEg6OmNoYXJvZmYiLCJUSDo6Y29sc3BhbiIsIlRIOjpoZWFkZXJzIiwiVEg6
-OmhlaWdodCIsIlRIOjpub3dyYXAiLCJUSDo6cm93c3BhbiIsIlRIOjpzY29wZSIsIlRIOjp2YWxpZ24i
-LCJUSDo6d2lkdGgiLCJUSEVBRDo6YWxpZ24iLCJUSEVBRDo6Y2hhciIsIlRIRUFEOjpjaGFyb2ZmIiwi
-VEhFQUQ6OnZhbGlnbiIsIlRSOjphbGlnbiIsIlRSOjpiZ2NvbG9yIiwiVFI6OmNoYXIiLCJUUjo6Y2hh
-cm9mZiIsIlRSOjp2YWxpZ24iLCJUUkFDSzo6ZGVmYXVsdCIsIlRSQUNLOjpraW5kIiwiVFJBQ0s6Omxh
-YmVsIiwiVFJBQ0s6OnNyY2xhbmciLCJVTDo6Y29tcGFjdCIsIlVMOjp0eXBlIiwiVklERU86OmNvbnRy
-b2xzIiwiVklERU86OmhlaWdodCIsIlZJREVPOjpsb29wIiwiVklERU86Om1lZGlhZ3JvdXAiLCJWSURF
-Tzo6bXV0ZWQiLCJWSURFTzo6cHJlbG9hZCIsIlZJREVPOjp3aWR0aCJdKSx0LmkpCkMuVkM9SC5WTShz
-KFswLDAsNjU0OTAsNDUwNTUsNjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMubUs9SC5WTShz
-KFswLDAsMjY2MjQsMTAyMyw2NTUzNCwyMDQ3LDY1NTM0LDIwNDddKSx0LlYpCkMuU3E9SC5WTShzKFsi
-SEVBRCIsIkFSRUEiLCJCQVNFIiwiQkFTRUZPTlQiLCJCUiIsIkNPTCIsIkNPTEdST1VQIiwiRU1CRUQi
-LCJGUkFNRSIsIkZSQU1FU0VUIiwiSFIiLCJJTUFHRSIsIklNRyIsIklOUFVUIiwiSVNJTkRFWCIsIkxJ
-TksiLCJNRVRBIiwiUEFSQU0iLCJTT1VSQ0UiLCJTVFlMRSIsIlRJVExFIiwiV0JSIl0pLHQuaSkKQy5o
-VT1ILlZNKHMoW10pLHQuYikKQy5kbj1ILlZNKHMoW10pLEguTjAoImpkPExMKj4iKSkKQy54RD1ILlZN
-KHMoW10pLHQuaSkKQy50bz1ILlZNKHMoWzAsMCwzMjcyMiwxMjI4Nyw2NTUzNCwzNDgxNSw2NTUzNCwx
-ODQzMV0pLHQuVikKQy5yaz1ILlZNKHMoW0MuQWQsQy5uZSxDLm15LEMucngsQy53VixDLmZSXSksSC5O
-MCgiamQ8SDcqPiIpKQpDLkYzPUguVk0ocyhbMCwwLDI0NTc2LDEwMjMsNjU1MzQsMzQ4MTUsNjU1MzQs
-MTg0MzFdKSx0LlYpCkMuZWE9SC5WTShzKFswLDAsMzI3NTQsMTEyNjMsNjU1MzQsMzQ4MTUsNjU1MzQs
-MTg0MzFdKSx0LlYpCkMuWko9SC5WTShzKFswLDAsMzI3MjIsMTIyODcsNjU1MzUsMzQ4MTUsNjU1MzQs
-MTg0MzFdKSx0LlYpCkMuV2Q9SC5WTShzKFswLDAsNjU0OTAsMTIyODcsNjU1MzUsMzQ4MTUsNjU1MzQs
-MTg0MzFdKSx0LlYpCkMuUXg9SC5WTShzKFsiYmluZCIsImlmIiwicmVmIiwicmVwZWF0Iiwic3ludGF4
-Il0pLHQuaSkKQy5CST1ILlZNKHMoWyJBOjpocmVmIiwiQVJFQTo6aHJlZiIsIkJMT0NLUVVPVEU6OmNp
-dGUiLCJCT0RZOjpiYWNrZ3JvdW5kIiwiQ09NTUFORDo6aWNvbiIsIkRFTDo6Y2l0ZSIsIkZPUk06OmFj
-dGlvbiIsIklNRzo6c3JjIiwiSU5QVVQ6OnNyYyIsIklOUzo6Y2l0ZSIsIlE6OmNpdGUiLCJWSURFTzo6
-cG9zdGVyIl0pLHQuaSkKQy5EeD1uZXcgSC5MUCgwLHt9LEMueEQsSC5OMCgiTFA8cVUqLHpNPGo4Kj4q
-PiIpKQpDLkNNPW5ldyBILkxQKDAse30sQy54RCxILk4wKCJMUDxxVSoscVUqPiIpKQpDLmlIPUguVk0o
-cyhbXSksSC5OMCgiamQ8R0QqPiIpKQpDLldPPW5ldyBILkxQKDAse30sQy5pSCxILk4wKCJMUDxHRCos
-QD4iKSkKQy5ZMj1uZXcgTC5POSgiTmF2aWdhdGlvblRyZWVOb2RlVHlwZS5kaXJlY3RvcnkiKQpDLnJm
-PW5ldyBMLk85KCJOYXZpZ2F0aW9uVHJlZU5vZGVUeXBlLmZpbGUiKQpDLlRlPW5ldyBILnd2KCJjYWxs
-IikKQy5vRT1uZXcgUC5HWSghMSkKQy53UT1uZXcgUC5GeShudWxsLDIpfSkoKTsoZnVuY3Rpb24gc3Rh
-dGljRmllbGRzKCl7JC56bT1udWxsCiQueWo9MAokLm1KPW51bGwKJC5QND1udWxsCiQuTkY9bnVsbAok
-LlRYPW51bGwKJC54Nz1udWxsCiQubnc9bnVsbAokLnZ2PW51bGwKJC5Cdj1udWxsCiQuUzY9bnVsbAok
-Lms4PW51bGwKJC5tZz1udWxsCiQuVUQ9ITEKJC5YMz1DLk5VCiQueGc9SC5WTShbXSxILk4wKCJqZDxN
-aD4iKSkKJC54bz1udWxsCiQuQk89bnVsbAokLmx0PW51bGwKJC5FVT1udWxsCiQub3I9UC5GbCh0Lk4s
-dC5ZKQokLklSPW51bGwKJC5JNj1udWxsCiQuRmY9bnVsbH0pKCk7KGZ1bmN0aW9uIGxhenlJbml0aWFs
-aXplcnMoKXt2YXIgcz1odW5rSGVscGVycy5sYXp5RmluYWwscj1odW5rSGVscGVycy5sYXp5T2xkCnMo
-JCwiZmEiLCJ3IixmdW5jdGlvbigpe3JldHVybiBILllnKCJfJGRhcnRfZGFydENsb3N1cmUiKX0pCnMo
-JCwiVTIiLCJTbiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHsKdG9TdHJpbmc6ZnVuY3Rpb24o
-KXtyZXR1cm4iJHJlY2VpdmVyJCJ9fSkpfSkKcygkLCJ4cSIsImxxIixmdW5jdGlvbigpe3JldHVybiBI
-LmNNKEguUzcoeyRtZXRob2QkOm51bGwsCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIiRyZWNlaXZl
-ciQifX0pKX0pCnMoJCwiUjEiLCJOOSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KG51bGwpKX0p
-CnMoJCwiZk4iLCJpSSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3ZhciAkYXJndW1l
-bnRzRXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7bnVsbC4kbWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNh
-dGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwicWkiLCJVTiIsZnVuY3Rpb24oKXtyZXR1
-cm4gSC5jTShILlM3KHZvaWQgMCkpfSkKcygkLCJyWiIsIlpoIixmdW5jdGlvbigpe3JldHVybiBILmNN
-KGZ1bmN0aW9uKCl7dmFyICRhcmd1bWVudHNFeHByJD0iJGFyZ3VtZW50cyQiCnRyeXsodm9pZCAwKS4k
-bWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMo
-JCwia3EiLCJyTiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILk1qKG51bGwpKX0pCnMoJCwidHQiLCJj
-MyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3RyeXtudWxsLiRtZXRob2QkfWNhdGNo
-KHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwiZHQiLCJISyIsZnVuY3Rpb24oKXtyZXR1cm4g
-SC5jTShILk1qKHZvaWQgMCkpfSkKcygkLCJBNyIsInIxIixmdW5jdGlvbigpe3JldHVybiBILmNNKGZ1
-bmN0aW9uKCl7dHJ5eyh2b2lkIDApLiRtZXRob2QkfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgp
-KX0pCnMoJCwiV2MiLCJ1dCIsZnVuY3Rpb24oKXtyZXR1cm4gUC5PaigpfSkKcygkLCJraCIsInJmIixm
-dW5jdGlvbigpe3JldHVybiBuZXcgUC54cigpLiQwKCl9KQpzKCQsImRIIiwiSEciLGZ1bmN0aW9uKCl7
-cmV0dXJuIG5ldyBQLk56KCkuJDAoKX0pCnMoJCwiYnQiLCJWNyIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3
-IEludDhBcnJheShILlhGKEguVk0oWy0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0y
+ZXBvcnRlZCBpc3N1ZSB3aXRoIE5OQkQgbWlncmF0aW9uIHRvb2w6ICIrYSwibGFiZWxzIix1LmQsImJv
+ZHkiLGErIlxuXG5FcnJvcjogIitILkVqKHMpKyJcblxuUGxlYXNlIGZpbGwgaW4gdGhlIGZvbGxvd2lu
+ZzpcblxuKipOYW1lIG9mIHBhY2thZ2UgYmVpbmcgbWlncmF0ZWQgKGlmIHB1YmxpYykqKjpcbioqV2hh
+dCBJIHdhcyBkb2luZyB3aGVuIHRoaXMgaXNzdWUgb2NjdXJyZWQqKjpcbioqSXMgaXQgcG9zc2libGUg
+dG8gd29yayBhcm91bmQgdGhpcyBpc3N1ZSoqOlxuKipIYXMgdGhpcyBpc3N1ZSBoYXBwZW5lZCBiZWZv
+cmUsIGFuZCBpZiBzbywgaG93IG9mdGVuKio6XG4qKkRhcnQgU0RLIHZlcnNpb24qKjogIitILkVqKG4u
+Z2V0RWxlbWVudEJ5SWQoInNkay12ZXJzaW9uIikudGV4dENvbnRlbnQpKyJcbioqQWRkaXRpb25hbCBk
+ZXRhaWxzKio6XG5cblRoYW5rcyBmb3IgZmlsaW5nIVxuXG5TdGFja3RyYWNlOiBfYXV0byBwb3B1bGF0
+ZWQgYnkgbWlncmF0aW9uIHByZXZpZXcgdG9vbC5fXG5cbmBgYFxuIitILkVqKGMpKyJcbmBgYFxuIl0s
+dC5YLHQueikpLmduRCgpKQpuPXEuc3R5bGUKbi5kaXNwbGF5PSJpbml0aWFsIgpuPXIuc3R5bGUKbi5k
+aXNwbGF5PSJpbml0aWFsIgpuPWErIjogIitILkVqKGIpCndpbmRvdwppZih0eXBlb2YgY29uc29sZSE9
+InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3IobikKd2luZG93Cm49SC5FaihjKQppZih0eXBl
+b2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3Iobil9LAp0MjpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG89dC5nLmEoVy5xYyhhLmN1cnJlbnRUYXJnZXQpKQphLnByZXZlbnRE
+ZWZhdWx0KCkKcz1vLmdldEF0dHJpYnV0ZSgiaHJlZiIpCnI9TC5VcyhzKQpxPUwuRzYocykKcD1MLmFL
+KHMpCmlmKHEhPW51bGwpTC5hZihyLHEscCxiLG5ldyBMLm5UKHIscSxwKSkKZWxzZSBMLmFmKHIsbnVs
+bCxudWxsLGIsbmV3IEwuTlkocikpfSwKSzA6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9ZG9jdW1lbnQu
+cXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKQpwLnF1ZXJ5U2VsZWN0b3IoImgyIikuaW5uZXJUZXh0
+PSJGYWlsZWQgdG8gcmVydW4gZnJvbSBzb3VyY2VzIgpwLnF1ZXJ5U2VsZWN0b3IoInAiKS5pbm5lclRl
+eHQ9IlNvdXJjZXMgY29udGFpbiBzdGF0aWMgYW5hbHlzaXMgZXJyb3JzOiIKcz1wLnF1ZXJ5U2VsZWN0
+b3IoInByZSIpCnI9Si5FbChhLHQuYXcpCnE9SC5MaChyKQpzLmlubmVyVGV4dD1uZXcgSC5sSihyLHEu
+QygicVUqKGxELkUpIikuYShuZXcgTC51ZSgpKSxxLkMoImxKPGxELkUscVUqPiIpKS5rKDAsIlxuIikK
+cT1wLnF1ZXJ5U2VsZWN0b3IoImEuYm90dG9tIikuc3R5bGUKcS5kaXNwbGF5PSJub25lIgpzPXAuc3R5
+bGUKcy5kaXNwbGF5PSJpbml0aWFsIn0sCnZVOmZ1bmN0aW9uKCl7dmFyIHM9ZG9jdW1lbnQKSC5EaCh0
+LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFsbCIpCnM9bmV3IFcud3oocy5xdWVyeVNlbGVjdG9yQWxs
+KCIuY29kZSIpLHQuUikKcy5LKHMsbmV3IEwuZVgoKSl9LApoWDpmdW5jdGlvbihhLGIsYyl7cmV0dXJu
+IEwuWXcoYSxiLGMpfSwKWXc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPTAscj1QLkZYKHQueikscT0xLHAs
+bz1bXSxuLG0sbCxrLGosaSxoLGcKdmFyICRhc3luYyRoWD1QLmx6KGZ1bmN0aW9uKGQsZSl7aWYoZD09
+PTEpe3A9ZQpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOnE9MwpqPXQuWApzPTYKcmV0dXJu
+IFAualEoTC5RNihhLFAuRUYoWyJyZWdpb24iLCJyZWdpb24iLCJvZmZzZXQiLEguRWooYildLGosaiks
+dC50KSwkYXN5bmMkaFgpCmNhc2UgNjpuPWUKaj1uCmk9Si5VNihqKQptPW5ldyBVLmQyKFUuamYoaS5x
+KGosImVkaXRzIikpLEguaChpLnEoaiwiZXhwbGFuYXRpb24iKSksSC51UChpLnEoaiwibGluZSIpKSxI
+LmgoaS5xKGosImRpc3BsYXlQYXRoIikpLEguaChpLnEoaiwidXJpUGF0aCIpKSxVLk5kKGkucShqLCJ0
+cmFjZXMiKSkpCkwuVDEobSkKTC5GcihhLGIsYykKTC55WCgiLmVkaXQtcGFuZWwgLnBhbmVsLWNvbnRl
+bnQiLCExKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKZz1wCmw9SC5SdShnKQprPUgudHMoZykKTC5D
+MigiQ291bGQgbm90IGxvYWQgZWRpdCBkZXRhaWxzIixsLGspCnM9NQpicmVhawpjYXNlIDI6cz0xCmJy
+ZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIpCmNhc2UgMTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJl
+dHVybiBQLkRJKCRhc3luYyRoWCxyKX0sCkc3OmZ1bmN0aW9uKGEsYixjLGQsZSl7cmV0dXJuIEwuTDUo
+YSxiLGMsZCxlKX0sCkw1OmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHM9MCxyPVAuRlgodC5IKSxxLHA9
+MixvLG49W10sbSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJEc3PVAubHooZnVuY3Rpb24oZixhMCl7aWYo
+Zj09PTEpe289YTAKcz1wfXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nhc2UgMDppZighSi5wNChhLCIuZGFy
+dCIpKXtMLkJFKGEsQi53UigpLGQpCkwuQlgoYSxudWxsKQppZihlIT1udWxsKWUuJDAoKQpzPTEKYnJl
+YWt9cD00Cmk9dC5YCnM9NwpyZXR1cm4gUC5qUShMLlE2KGEsUC5FRihbImlubGluZSIsInRydWUiXSxp
+LGkpLHQudCksJGFzeW5jJEc3KQpjYXNlIDc6bT1hMApMLkJFKGEsQi5ZZihtKSxkKQpMLmZHKGIsYykK
+bD1MLlVzKGEpCkwuQlgobCxiKQppZihlIT1udWxsKWUuJDAoKQpwPTIKcz02CmJyZWFrCmNhc2UgNDpw
+PTMKZz1vCms9SC5SdShnKQpqPUgudHMoZykKTC5DMigiQ291bGQgbm90IGxvYWQgZGFydCBmaWxlICIr
+YSxrLGopCnM9NgpicmVhawpjYXNlIDM6cz0yCmJyZWFrCmNhc2UgNjpjYXNlIDE6cmV0dXJuIFAueUMo
+cSxyKQpjYXNlIDI6cmV0dXJuIFAuZjMobyxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkRzcscil9LApH
+ZTpmdW5jdGlvbigpe3ZhciBzPTAscj1QLkZYKHQueikscT0xLHAsbz1bXSxuLG0sbCxrLGosaSxoLGcK
+dmFyICRhc3luYyRHZT1QLmx6KGZ1bmN0aW9uKGEsYil7aWYoYT09PTEpe3A9YgpzPXF9d2hpbGUodHJ1
+ZSlzd2l0Y2gocyl7Y2FzZSAwOmg9Ii9fcHJldmlldy9uYXZpZ2F0aW9uVHJlZS5qc29uIgpxPTMKcz02
+CnJldHVybiBQLmpRKEwuUTYoaCxDLkNNLHQuZUUpLCRhc3luYyRHZSkKY2FzZSA2Om49YgptPWRvY3Vt
+ZW50LnF1ZXJ5U2VsZWN0b3IoIi5uYXYtdHJlZSIpCkoubDUobSwiIikKaj1MLm1LKG4pCiQuSVI9agpM
+LnRYKG0saiwhMCkKcT0xCnM9NQpicmVhawpjYXNlIDM6cT0yCmc9cApsPUguUnUoZykKaz1ILnRzKGcp
+CkwuQzIoIkNvdWxkIG5vdCBsb2FkIG5hdmlnYXRpb24gdHJlZSIsbCxrKQpzPTUKYnJlYWsKY2FzZSAy
+OnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxy
+KX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkR2Uscil9LApxTzpmdW5jdGlvbihhKXt2YXIgcyxyPWEuZ2V0
+Qm91bmRpbmdDbGllbnRSZWN0KCkscT1DLkNELnpRKCQuZmkoKS5vZmZzZXRIZWlnaHQpLHA9d2luZG93
+LmlubmVySGVpZ2h0LG89Qy5DRC56USgkLkRXKCkub2Zmc2V0SGVpZ2h0KQppZih0eXBlb2YgcCE9PSJu
+dW1iZXIiKXJldHVybiBwLkhOKCkKcz1yLmJvdHRvbQpzLnRvU3RyaW5nCmlmKHM+cC0obysxNCkpSi5k
+aChhKQplbHNle3A9ci50b3AKcC50b1N0cmluZwppZihwPHErMTQpSi5kaChhKX19LApmRzpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG8KaWYoYSE9bnVsbCl7cz1kb2N1bWVudApyPXMuZ2V0RWxlbWVudEJ5
+SWQoIm8iK0guRWooYSkpCnE9cy5xdWVyeVNlbGVjdG9yKCIubGluZS0iK0guRWooYikpCmlmKHIhPW51
+bGwpe0wucU8ocikKSi5kUihyKS5pKDAsInRhcmdldCIpfWVsc2UgaWYocSE9bnVsbClMLnFPKHEucGFy
+ZW50RWxlbWVudCkKaWYocSE9bnVsbClKLmRSKHQuZy5hKHEucGFyZW50Tm9kZSkpLmkoMCwiaGlnaGxp
+Z2h0Iil9ZWxzZXtzPWRvY3VtZW50CnA9dC5nCkguRGgocCx0LmgsIlQiLCJxdWVyeVNlbGVjdG9yQWxs
+IikKcz1zLnF1ZXJ5U2VsZWN0b3JBbGwoIi5saW5lLW5vIikKbz1uZXcgVy53eihzLHQuUikKaWYoby5n
+QShvKT09PTApcmV0dXJuCkwucU8ocC5hKEMudDUuZ3RIKHMpKSl9fSwKYWY6ZnVuY3Rpb24oYSxiLGMs
+ZCxlKXt2YXIgcyxyLHE9TC5HNih3aW5kb3cubG9jYXRpb24uaHJlZikscD1MLmFLKHdpbmRvdy5sb2Nh
+dGlvbi5ocmVmKQppZihxIT1udWxsKXtzPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJvIitILkVqKHEp
+KQppZihzIT1udWxsKUouZFIocykuUigwLCJ0YXJnZXQiKX1pZihwIT1udWxsKXtyPWRvY3VtZW50LnF1
+ZXJ5U2VsZWN0b3IoIi5saW5lLSIrSC5FaihwKSkKaWYociE9bnVsbClKLmRSKHIucGFyZW50RWxlbWVu
+dCkuUigwLCJoaWdobGlnaHQiKX1pZihhPT13aW5kb3cubG9jYXRpb24ucGF0aG5hbWUpe0wuZkcoYixj
+KQplLiQwKCl9ZWxzZSBMLkc3KGEsYixjLGQsZSl9LApRNDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1Q
+LmhLKGEpLHA9dC5YCnA9UC5GbChwLHApCmZvcihzPXEuZ2hZKCkscz1zLmdQdShzKSxzPXMuZ20ocyk7
+cy5GKCk7KXtyPXMuZ2woKQpwLlk1KDAsci5hLHIuYil9Zm9yKHM9Yi5nUHUoYikscz1zLmdtKHMpO3Mu
+RigpOyl7cj1zLmdsKCkKcC5ZNSgwLHIuYSxyLmIpfXAuWTUoMCwiYXV0aFRva2VuIiwkLlVFKCkpCnJl
+dHVybiBxLm5tKDAscCkuZ25EKCl9LApUMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGss
+aj0kLmhMKCkKSi5sNShqLCIiKQppZihhPT1udWxsKXtzPWRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInAi
+KQpDLkx0LnNhNChzLCJTZWUgZGV0YWlscyBhYm91dCBhIHByb3Bvc2VkIGVkaXQuIikKQy5MdC5zUChz
+LEguVk0oWyJwbGFjZWhvbGRlciJdLHQuaSkpCmouYXBwZW5kQ2hpbGQocykKQy5MdC5GRihzKQpyZXR1
+cm59cj1hLmQKcT0kLm5VKCkKcD1xLnpmKHIpCm89YS5iCm49ZG9jdW1lbnQKbT1xLkhQKHIsSi5UMChu
+LnF1ZXJ5U2VsZWN0b3IoIi5yb290IikudGV4dENvbnRlbnQpKQpsPWEuYwprPW4uY3JlYXRlRWxlbWVu
+dCgicCIpCmouYXBwZW5kQ2hpbGQoaykKay5hcHBlbmRDaGlsZChuLmNyZWF0ZVRleHROb2RlKEguRWoo
+bykrIiBhdCAiKSkKcT10LlgKcT1XLko2KEwuUTQoYS5lLFAuRUYoWyJsaW5lIixKLmoobCldLHEscSkp
+KQpxLmFwcGVuZENoaWxkKG4uY3JlYXRlVGV4dE5vZGUoSC5FaihtKSsiOiIrSC5FaihsKSsiLiIpKQpr
+LmFwcGVuZENoaWxkKHEpCkouZGgoaykKTC5DQyhhLGoscCkKTC5GeihhLGopfSwKTEg6ZnVuY3Rpb24o
+YSxiLGMpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYsZT0kLnlQKCkKSi5sNShlLCIiKQpp
+ZihiLmdBKGIpPT09MCl7cz1kb2N1bWVudApyPXMuY3JlYXRlRWxlbWVudCgicCIpCmUuYXBwZW5kQ2hp
+bGQocikKci5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKCJObyBwcm9wb3NlZCBlZGl0cyIpKX1l
+bHNlIGZvcihlPWIuZ1B1KGIpLGU9ZS5nbShlKSxzPXQuWCxxPXQuayxwPXEuQygifigxKT8iKSxvPXQu
+WixxPXEuYztlLkYoKTspe249ZS5nbCgpCm09ZG9jdW1lbnQKcj1tLmNyZWF0ZUVsZW1lbnQoInAiKQps
+PSQueVAoKQpsLmFwcGVuZENoaWxkKHIpCnIuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZShILkVq
+KG4uYSkrIjoiKSkKaz1tLmNyZWF0ZUVsZW1lbnQoInVsIikKbC5hcHBlbmRDaGlsZChrKQpmb3Iobj1K
+LklUKG4uYik7bi5GKCk7KXtsPW4uZ2woKQpqPW0uY3JlYXRlRWxlbWVudCgibGkiKQprLmFwcGVuZENo
+aWxkKGopCkouZFIoaikuaSgwLCJlZGl0IikKaT1tLmNyZWF0ZUVsZW1lbnQoImEiKQpqLmFwcGVuZENo
+aWxkKGkpCmkuY2xhc3NMaXN0LmFkZCgiZWRpdC1saW5rIikKaD1sLmMKZz1ILkVqKGgpCmkuc2V0QXR0
+cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcoaSkpLk9VKCJvZmZzZXQiKSxnKQpmPWwuYQpn
+PUguRWooZikKaS5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhpKSkuT1UoImxp
+bmUiKSxnKQppLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoImxpbmUgIitILkVqKGYpKSkKaS5z
+ZXRBdHRyaWJ1dGUoImhyZWYiLEwuUTQod2luZG93LmxvY2F0aW9uLnBhdGhuYW1lLFAuRUYoWyJsaW5l
+IixILkVqKGYpLCJvZmZzZXQiLEguRWooaCldLHMscykpKQpnPXAuYShuZXcgTC5FRShoLGYsYSkpCm8u
+YShudWxsKQpXLkpFKGksImNsaWNrIixnLCExLHEpCmouYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9k
+ZSgiOiAiK0guRWoobC5iKSkpfX1pZihjKUwuVDEobnVsbCl9LApGcjpmdW5jdGlvbihhLGIsYyl7dmFy
+IHMscixxPXdpbmRvdy5sb2NhdGlvbixwPVAuaEsoKHEmJkMuRXgpLmdEcihxKStILkVqKGEpKQpxPXQu
+WApxPVAuRmwocSxxKQppZihiIT1udWxsKXEuWTUoMCwib2Zmc2V0IixILkVqKGIpKQppZihjIT1udWxs
+KXEuWTUoMCwibGluZSIsSC5FaihjKSkKcS5ZNSgwLCJhdXRoVG9rZW4iLCQuVUUoKSkKcD1wLm5tKDAs
+cSkKcT13aW5kb3cuaGlzdG9yeQpzPXQuegpyPXAuZ25EKCkKcS50b1N0cmluZwpxLnB1c2hTdGF0ZShu
+ZXcgUC5CZihbXSxbXSkuUHYoUC5GbChzLHMpKSwiIixyKX0sCkVuOmZ1bmN0aW9uKGEpe3ZhciBzPUou
+YmIoZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29udGVudCwiLyIpCmlmKEMueEIu
+bihhLHMpKXJldHVybiBDLnhCLnluKGEscy5sZW5ndGgpCmVsc2UgcmV0dXJuIGF9LApPdDpmdW5jdGlv
+bihhKXtzd2l0Y2goYS5yKXtjYXNlIEMuY3c6YnJlYWsKY2FzZSBDLldEOmEucj1DLlhqCmJyZWFrCmNh
+c2UgQy5YajphLnI9Qy5XRApicmVhawpjYXNlIEMuZGM6dGhyb3cgSC5iKFAuUFYoIkZpbGUgIitILkVq
+KGEuYykrIiBzaG91bGQgbm90IGhhdmUgaW5kZXRlcm1pbmF0ZSBtaWdyYXRpb24gc3RhdHVzIikpfX0s
+CnhuOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPSJkaXNhYmxlZCIscD1iLmdMKCkKTC50YShhLHApCmlm
+KGIuYz09JC5EOSgpLmlubmVyVGV4dCl7cz1iIGluc3RhbmNlb2YgTC5jRCYmIUgub1QoYi54KQpyPUou
+WUUoYSkKaWYocylyLmdQKGEpLmkoMCxxKQplbHNlIHIuZ1AoYSkuUigwLHEpCkwudGEoJC5jMCgpLHAp
+fX0sCnRhOmZ1bmN0aW9uKGEsYil7dmFyIHMscj0iY2hlY2tfYm94IixxPSJ0aXRsZSIscD0ib3B0ZWQt
+b3V0IixvPSJtaWdyYXRpbmciCnN3aXRjaChiKXtjYXNlIEMuY3c6YS5pbm5lclRleHQ9cgpzPUouWUUo
+YSkKcy5nUChhKS5pKDAsImFscmVhZHktbWlncmF0ZWQiKQpzLmdQKGEpLmkoMCwiZGlzYWJsZWQiKQph
+LnNldEF0dHJpYnV0ZShxLCJBbHJlYWR5IG1pZ3JhdGVkIikKYnJlYWsKY2FzZSBDLldEOmEuaW5uZXJU
+ZXh0PXIKcz1KLllFKGEpCnMuZ1AoYSkuUigwLHApCnMuZ1AoYSkuaSgwLG8pCmEuc2V0QXR0cmlidXRl
+KHEsIk1pZ3JhdGluZyB0byBudWxsIHNhZmV0eSIpCmJyZWFrCmNhc2UgQy5YajphLmlubmVyVGV4dD0i
+Y2hlY2tfYm94X291dGxpbmVfYmxhbmsiCnM9Si5ZRShhKQpzLmdQKGEpLlIoMCxvKQpzLmdQKGEpLmko
+MCxwKQphLnNldEF0dHJpYnV0ZShxLCJPcHRpbmcgb3V0IG9mIG51bGwgc2FmZXR5IikKYnJlYWsKZGVm
+YXVsdDphLmlubmVyVGV4dD0iaW5kZXRlcm1pbmF0ZV9jaGVja19ib3giCnM9Si5ZRShhKQpzLmdQKGEp
+LlIoMCxvKQpzLmdQKGEpLmkoMCxwKQphLnNldEF0dHJpYnV0ZShxLCJNaXhlZCBzdGF0dXNlcyBvZiAn
+bWlncmF0aW5nJyBhbmQgJ29wdGluZyBvdXQnIikKYnJlYWt9fSwKQlg6ZnVuY3Rpb24oYSxiKXt2YXIg
+cyxyLHE9e30KcS5hPWEKYT1MLkVuKGEpCnEuYT1hCkouZHIoJC5EOSgpLGEpCnM9ZG9jdW1lbnQKSC5E
+aCh0LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFsbCIpCnM9bmV3IFcud3oocy5xdWVyeVNlbGVjdG9y
+QWxsKCIubmF2LXBhbmVsIC5uYXYtbGluayIpLHQuUikKcy5LKHMsbmV3IEwuVlMocSkpCnI9TC5tSCgk
+LklSLHEuYSkKaWYocj09bnVsbClKLmRSKCQuYk4oKSkuUigwLCJ2aXNpYmxlIikKZWxzZXtKLmRSKCQu
+Yk4oKSkuaSgwLCJ2aXNpYmxlIikKTC50YSgkLmMwKCksci5nTCgpKX19LApBUjpmdW5jdGlvbihhLGIp
+e3ZhciBzLHIscT1iLmIKaWYocSE9bnVsbCl7cz10LmcKcj1zLmEocy5hKGEucGFyZW50Tm9kZSkucGFy
+ZW50Tm9kZSkKTC54bihyLnF1ZXJ5U2VsZWN0b3IoIjpzY29wZSA+IC5zdGF0dXMtaWNvbiIpLHEpCkwu
+QVIocixxKX19LApobDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtPSI6c2NvcGUgPiAuc3Rh
+dHVzLWljb24iCmZvcihzPWIuZCxyPXMubGVuZ3RoLHE9dC5nLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3Ro
+PT09cnx8KDAsSC5saykocyksKytwKXtvPXNbcF0Kbj1hLnF1ZXJ5U2VsZWN0b3IoJ1tkYXRhLW5hbWUq
+PSInK0guRWooby5jKSsnIl0nKQppZihvIGluc3RhbmNlb2YgTC52dCl7TC5obChuLG8pCkwueG4obi5x
+dWVyeVNlbGVjdG9yKG0pLGIpfWVsc2UgTC54bihxLmEobi5wYXJlbnROb2RlKS5xdWVyeVNlbGVjdG9y
+KG0pLG8pfX0sCkJFOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz0iLnJlZ2lvbnMiLHI9ZG9jdW1lbnQscT1y
+LnF1ZXJ5U2VsZWN0b3IocykscD1yLnF1ZXJ5U2VsZWN0b3IoIi5jb2RlIikKSi50SChxLGIuYSwkLktH
+KCkpCkoudEgocCxiLmIsJC5LRygpKQpMLkxIKGEsYi5kLGMpCmlmKGIuYy5sZW5ndGg8MmU1KUwudlUo
+KQpMLnlYKCIuY29kZSIsITApCkwueVgocywhMCl9LAp0WDpmdW5jdGlvbihhMSxhMixhMyl7dmFyIHMs
+cixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQsYz0ibWF0ZXJpYWwtaWNvbnMiLGI9InN0YXR1cy1p
+Y29uIixhPWRvY3VtZW50LGEwPWEuY3JlYXRlRWxlbWVudCgidWwiKQphMS5hcHBlbmRDaGlsZChhMCkK
+Zm9yKHM9YTIubGVuZ3RoLHI9dC5YLHE9dC5aLHA9MDtwPGEyLmxlbmd0aDthMi5sZW5ndGg9PT1zfHwo
+MCxILmxrKShhMiksKytwKXtvPWEyW3BdCm49YS5jcmVhdGVFbGVtZW50KCJsaSIpCmEwLmFwcGVuZENo
+aWxkKG4pCmlmKG8gaW5zdGFuY2VvZiBMLnZ0KXttPUouWUUobikKbS5nUChuKS5pKDAsImRpciIpCm4u
+c2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcobikpLk9VKCJuYW1lIiksby5jKQps
+PWEuY3JlYXRlRWxlbWVudCgic3BhbiIpCm4uYXBwZW5kQ2hpbGQobCkKaz1KLllFKGwpCmsuZ1AobCku
+aSgwLCJhcnJvdyIpCmsuc2hmKGwsIiYjeDI1QkM7IikKaj1hLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpK
+LmRSKGopLmkoMCxjKQpqLmlubmVyVGV4dD0iZm9sZGVyX29wZW4iCm4uYXBwZW5kQ2hpbGQoaikKbi5h
+cHBlbmRDaGlsZChhLmNyZWF0ZVRleHROb2RlKG8uYSkpCkwudFgobixvLmQsITApCmk9YS5jcmVhdGVF
+bGVtZW50KCJzcGFuIikKaz1KLllFKGkpCmsuZ1AoaSkuaSgwLGMpCmkuaW5uZXJUZXh0PSJpbmRldGVy
+bWluYXRlX2NoZWNrX2JveCIKay5nUChpKS5pKDAsYikKTC54bihpLG8pCms9ay5nVmwoaSkKaD1rLiR0
+aQpnPWguQygifigxKT8iKS5hKG5ldyBMLlREKG8sbixpKSkKcS5hKG51bGwpClcuSkUoay5hLGsuYixn
+LCExLGguYykKbS5tSyhuLGksaikKTC5reihsKX1lbHNlIGlmKG8gaW5zdGFuY2VvZiBMLmNEKXtpPWEu
+Y3JlYXRlRWxlbWVudCgic3BhbiIpCm09Si5ZRShpKQptLmdQKGkpLmkoMCxjKQppLmlubmVyVGV4dD0i
+IgptLmdQKGkpLmkoMCxiKQprPUgub1Qoby54KQppZighayltLmdQKGkpLmkoMCwiZGlzYWJsZWQiKQpM
+LnhuKGksbykKaWYoayl7bT1tLmdWbChpKQprPW0uJHRpCmg9ay5DKCJ+KDEpPyIpLmEobmV3IEwuSWYo
+byxpLG4pKQpxLmEobnVsbCkKVy5KRShtLmEsbS5iLGgsITEsay5jKX1uLmFwcGVuZENoaWxkKGkpCm09
+YS5jcmVhdGVFbGVtZW50KCJzcGFuIikKSi5kUihtKS5pKDAsYykKbS5pbm5lclRleHQ9Imluc2VydF9k
+cml2ZV9maWxlIgpuLmFwcGVuZENoaWxkKG0pCmY9YS5jcmVhdGVFbGVtZW50KCJhIikKbi5hcHBlbmRD
+aGlsZChmKQptPUouWUUoZikKbS5nUChmKS5pKDAsIm5hdi1saW5rIikKZi5zZXRBdHRyaWJ1dGUoImRh
+dGEtIituZXcgVy5TeShuZXcgVy5pNyhmKSkuT1UoIm5hbWUiKSxvLmMpCmYuc2V0QXR0cmlidXRlKCJo
+cmVmIixMLlE0KG8uZCxQLkZsKHIscikpKQpmLmFwcGVuZENoaWxkKGEuY3JlYXRlVGV4dE5vZGUoby5h
+KSkKbT1tLmdWbChmKQprPW0uJHRpCmg9ay5DKCJ+KDEpPyIpLmEobmV3IEwudEIoKSkKcS5hKG51bGwp
+ClcuSkUobS5hLG0uYixoLCExLGsuYykKZT1vLmUKaWYodHlwZW9mIGUhPT0ibnVtYmVyIilyZXR1cm4g
+ZS5vcygpCmlmKGU+MCl7ZD1hLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpuLmFwcGVuZENoaWxkKGQpCkou
+ZFIoZCkuaSgwLCJlZGl0LWNvdW50IikKbT0iIitlKyIgIgppZihlPT09MSlrPSJwcm9wb3NlZCBlZGl0
+IgplbHNlIGs9InByb3Bvc2VkIGVkaXRzIgpkLnNldEF0dHJpYnV0ZSgidGl0bGUiLG0raykKZC5hcHBl
+bmRDaGlsZChhLmNyZWF0ZVRleHROb2RlKEMuam4udyhlKSkpfX19fSwKdXo6ZnVuY3Rpb24oYSxiLGMp
+e3ZhciBzPWRvY3VtZW50LHI9cy5jcmVhdGVFbGVtZW50KCJidXR0b24iKSxxPXQuayxwPXEuQygifigx
+KT8iKS5hKG5ldyBMLm0yKGEsYykpCnQuWi5hKG51bGwpClcuSkUociwiY2xpY2siLHAsITEscS5jKQpy
+LmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUoUi5PWChhLmEpKSkKYi5hcHBlbmRDaGlsZChyKX0s
+CkZ6OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoPWEuYQppZihoPT1udWxs
+KXJldHVybgpzPWRvY3VtZW50CnI9cy5jcmVhdGVFbGVtZW50KCJwIikKcT1iLmFwcGVuZENoaWxkKHIp
+CnI9cy5jcmVhdGVFbGVtZW50KCJzcGFuIikKcD10LmkKSi5NdShyLEguVk0oWyJ0eXBlLWRlc2NyaXB0
+aW9uIl0scCkpCnIuYXBwZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgiQWN0aW9ucyIpKQpxLmFwcGVu
+ZENoaWxkKHIpCnEuYXBwZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgiOiIpKQpvPXMuY3JlYXRlRWxl
+bWVudCgicCIpCmIuYXBwZW5kQ2hpbGQobykKZm9yKHI9aC5sZW5ndGgsbj10LlEsbT0wO208aC5sZW5n
+dGg7aC5sZW5ndGg9PT1yfHwoMCxILmxrKShoKSwrK20pe2w9aFttXQprPXMuY3JlYXRlRWxlbWVudCgi
+YSIpCm8uYXBwZW5kQ2hpbGQoaykKay5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKGwuYSkpCmsu
+c2V0QXR0cmlidXRlKCJocmVmIixsLmIpCmo9bi5hKEguVk0oWyJhZGQtaGludC1saW5rIiwiYmVmb3Jl
+LWFwcGx5IiwiYnV0dG9uIl0scCkpCmk9Si5kUihrKQppLlYxKDApCmkuRlYoMCxqKX19LApDQzpmdW5j
+dGlvbihhNCxhNSxhNil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQsYyxiLGEsYTAs
+YTEsYTIsYTMKZm9yKHM9YTQuZixyPXMubGVuZ3RoLHE9dC5pLHA9dC5RLG89MDtvPHMubGVuZ3RoO3Mu
+bGVuZ3RoPT09cnx8KDAsSC5saykocyksKytvKXtuPXNbb10KbT1kb2N1bWVudApsPW0uY3JlYXRlRWxl
+bWVudCgicCIpCms9cC5hKEguVk0oWyJ0cmFjZSJdLHEpKQpqPUouZFIobCkKai5WMSgwKQpqLkZWKDAs
+aykKaT1hNS5hcHBlbmRDaGlsZChsKQpsPW0uY3JlYXRlRWxlbWVudCgic3BhbiIpCms9cC5hKEguVk0o
+WyJ0eXBlLWRlc2NyaXB0aW9uIl0scSkpCmo9Si5kUihsKQpqLlYxKDApCmouRlYoMCxrKQpsLmFwcGVu
+ZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUobi5hKSkKaS5hcHBlbmRDaGlsZChsKQppLmFwcGVuZENoaWxk
+KG0uY3JlYXRlVGV4dE5vZGUoIjoiKSkKbD1tLmNyZWF0ZUVsZW1lbnQoInVsIikKaz1wLmEoSC5WTShb
+InRyYWNlIl0scSkpCmo9Si5kUihsKQpqLlYxKDApCmouRlYoMCxrKQpoPWkuYXBwZW5kQ2hpbGQobCkK
+Zm9yKGw9bi5iLGs9bC5sZW5ndGgsZz0wO2c8bC5sZW5ndGg7bC5sZW5ndGg9PT1rfHwoMCxILmxrKShs
+KSwrK2cpe2Y9bFtnXQplPW0uY3JlYXRlRWxlbWVudCgibGkiKQpoLmFwcGVuZENoaWxkKGUpCmQ9bS5j
+cmVhdGVFbGVtZW50KCJzcGFuIikKYz1wLmEoSC5WTShbImZ1bmN0aW9uIl0scSkpCmo9Si5kUihkKQpq
+LlYxKDApCmouRlYoMCxjKQpjPWYuYgpMLmtEKGQsYz09bnVsbD8idW5rbm93biI6YykKZS5hcHBlbmRD
+aGlsZChkKQpiPWYuYwppZihiIT1udWxsKXtlLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoIiAo
+IikpCmE9Yi5iCmEwPW0uY3JlYXRlRWxlbWVudCgiYSIpCmEwLmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4
+dE5vZGUoSC5FaihiLmMpKyI6IitILkVqKGEpKSkKYTAuc2V0QXR0cmlidXRlKCJocmVmIixiLmEpCmEw
+LmNsYXNzTGlzdC5hZGQoIm5hdi1saW5rIikKZS5hcHBlbmRDaGlsZChhMCkKZS5hcHBlbmRDaGlsZCht
+LmNyZWF0ZVRleHROb2RlKCIpIikpfWUuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiKSkK
+ZD1mLmEKTC5rRChlLGQ9PW51bGw/InVua25vd24iOmQpCmQ9Zi5kCmlmKGQubGVuZ3RoIT09MCl7Yz1t
+LmNyZWF0ZUVsZW1lbnQoInAiKQphMT1wLmEoSC5WTShbImRyYXdlciIsImJlZm9yZS1hcHBseSJdLHEp
+KQpqPUouZFIoYykKai5WMSgwKQpqLkZWKDAsYTEpCmEyPWUuYXBwZW5kQ2hpbGQoYykKZm9yKGM9ZC5s
+ZW5ndGgsYTM9MDthMzxkLmxlbmd0aDtkLmxlbmd0aD09PWN8fCgwLEgubGspKGQpLCsrYTMpTC51eihk
+W2EzXSxhMixiKX19fX0sClVzOmZ1bmN0aW9uKGEpe3JldHVybiBKLlU2KGEpLnRnKGEsIj8iKT9DLnhC
+Lk5qKGEsMCxDLnhCLk9ZKGEsIj8iKSk6YX0sCmtEOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPUguVk0o
+Yi5zcGxpdCgiLiIpLHQucykscD1DLk5tLmd0SChxKSxvPWRvY3VtZW50CmEuYXBwZW5kQ2hpbGQoby5j
+cmVhdGVUZXh0Tm9kZShwKSkKZm9yKHA9SC5xQyhxLDEsbnVsbCx0Lk4pLHA9bmV3IEguYTcocCxwLmdB
+KHApLHAuJHRpLkMoImE3PGFMLkU+IikpLHM9Si5ZRShhKTtwLkYoKTspe3I9cC5kCnMubnooYSwiYmVm
+b3JlZW5kIiwiJiM4MjAzOy4iLG51bGwsbnVsbCkKYS5hcHBlbmRDaGlsZChvLmNyZWF0ZVRleHROb2Rl
+KHIpKX19LAptSDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwCmZvcihzPWEubGVuZ3RoLHI9MDtyPGEu
+bGVuZ3RoO2EubGVuZ3RoPT09c3x8KDAsSC5saykoYSksKytyKXtxPWFbcl0KaWYocSBpbnN0YW5jZW9m
+IEwudnQpe3A9TC5tSChxLmQsYikKaWYocCE9bnVsbClyZXR1cm4gcH1lbHNlIGlmKHEuYz09YilyZXR1
+cm4gcX1yZXR1cm4gbnVsbH0sCmU6ZnVuY3Rpb24gZSgpe30sClZXOmZ1bmN0aW9uIFZXKGEsYixjKXt0
+aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCm9aOmZ1bmN0aW9uIG9aKCl7fSwKanI6ZnVuY3Rpb24g
+anIoKXt9LApxbDpmdW5jdGlvbiBxbCgpe30sCkhpOmZ1bmN0aW9uIEhpKCl7fSwKQlQ6ZnVuY3Rpb24g
+QlQoKXt9LApQWTpmdW5jdGlvbiBQWSgpe30sCnU4OmZ1bmN0aW9uIHU4KCl7fSwKTDpmdW5jdGlvbiBM
+KCl7fSwKV3g6ZnVuY3Rpb24gV3goYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkFPOmZ1bmN0aW9uIEFP
+KGEpe3RoaXMuYT1hfSwKZE46ZnVuY3Rpb24gZE4oYSl7dGhpcy5hPWF9LApIbzpmdW5jdGlvbiBIbyhh
+KXt0aGlzLmE9YX0sCnh6OmZ1bmN0aW9uIHh6KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApJQzpmdW5j
+dGlvbiBJQygpe30sCmZDOmZ1bmN0aW9uIGZDKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApuVDpmdW5j
+dGlvbiBuVChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApOWTpmdW5jdGlvbiBOWShh
+KXt0aGlzLmE9YX0sCnVlOmZ1bmN0aW9uIHVlKCl7fSwKZVg6ZnVuY3Rpb24gZVgoKXt9LApFRTpmdW5j
+dGlvbiBFRShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApRTDpmdW5jdGlvbiBRTChh
+LGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKVlM6ZnVuY3Rpb24gVlMoYSl7dGhpcy5hPWF9LApURDpmdW5j
+dGlvbiBURChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApJZjpmdW5jdGlvbiBJZihh
+LGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LAp0QjpmdW5jdGlvbiB0Qigpe30sCm0yOmZ1
+bmN0aW9uIG0yKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApYQTpmdW5jdGlvbiBYQSgpe30sClpzOmZ1
+bmN0aW9uKGEpe3ZhciBzLHIscT1KLlU2KGEpCmlmKEwucDIoSC5oKHEucShhLCJ0eXBlIikpKT09PUMu
+WTIpe3M9SC5oKHEucShhLCJuYW1lIikpCnI9SC5oKHEucShhLCJwYXRoIikpCnE9cS5xKGEsInN1YnRy
+ZWUiKQpxPW5ldyBMLnZ0KHE9PW51bGw/bnVsbDpMLm1LKHEpLHMscikKcS5MVigpCnJldHVybiBxfWVs
+c2V7cz1ILmgocS5xKGEsIm5hbWUiKSkKcj1ILmgocS5xKGEsInBhdGgiKSkKcmV0dXJuIG5ldyBMLmNE
+KEguaChxLnEoYSwiaHJlZiIpKSxILnVQKHEucShhLCJlZGl0Q291bnQiKSksSC55OChxLnEoYSwid2Fz
+RXhwbGljaXRseU9wdGVkT3V0IikpLEwudkIoSC51UChxLnEoYSwibWlncmF0aW9uU3RhdHVzIikpKSxI
+Lnk4KHEucShhLCJtaWdyYXRpb25TdGF0dXNDYW5CZUNoYW5nZWQiKSkscyxyKX19LAptSzpmdW5jdGlv
+bihhKXt2YXIgcyxyPUguVk0oW10sdC5jUSkKZm9yKHM9Si5JVCh0LlUuYShhKSk7cy5GKCk7KXIucHVz
+aChMLlpzKHMuZ2woKSkpCnJldHVybiByfSwKVkQ6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUguVk0oW10s
+dC5HKQpmb3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDthLmxlbmd0aD09PXN8fCgwLEgubGspKGEp
+LCsrcilxLnB1c2goYVtyXS5MdCgpKQpyZXR1cm4gcX0sCnZCOmZ1bmN0aW9uKGEpe2lmKGE9PW51bGwp
+cmV0dXJuIG51bGwKaWYoYT4+PjAhPT1hfHxhPj00KXJldHVybiBILk9IKEMubDAsYSkKcmV0dXJuIEMu
+bDBbYV19LApwMjpmdW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSJkaXJlY3RvcnkiOnJldHVybiBDLlky
+CmNhc2UiZmlsZSI6cmV0dXJuIEMucmYKZGVmYXVsdDp0aHJvdyBILmIoUC5QVigiVW5yZWNvZ25pemVk
+IG5hdmlnYXRpb24gdHJlZSBub2RlIHR5cGU6ICIrSC5FaihhKSkpfX0sCnZ0OmZ1bmN0aW9uIHZ0KGEs
+YixjKXt2YXIgXz10aGlzCl8uZD1hCl8uYT1iCl8uYj1udWxsCl8uYz1jfSwKY0Q6ZnVuY3Rpb24gY0Qo
+YSxiLGMsZCxlLGYsZyl7dmFyIF89dGhpcwpfLmQ9YQpfLmU9YgpfLmY9YwpfLnI9ZApfLng9ZQpfLmE9
+ZgpfLmI9bnVsbApfLmM9Z30sCkQ4OmZ1bmN0aW9uIEQ4KCl7fSwKTzk6ZnVuY3Rpb24gTzkoYSl7dGhp
+cy5iPWF9LApHYjpmdW5jdGlvbiBHYihhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKSVY6ZnVuY3Rpb24g
+SVYoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmQ9YQpfLmU9YgpfLmY9YwpfLnI9ZH19LFI9ewpuejpmdW5j
+dGlvbihhKXt2YXIgcz1ILnVQKGEucSgwLCJub2RlSWQiKSkKcmV0dXJuIG5ldyBSLkxMKEMuTm0uSHQo
+Qy5yayxuZXcgUi5NRChhKSkscyl9LApPWDpmdW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSBDLkFkOnJl
+dHVybiJBZGQgLyo/Ki8gaGludCIKY2FzZSBDLm5lOnJldHVybiJBZGQgLyohKi8gaGludCIKY2FzZSBD
+LndWOnJldHVybiJSZW1vdmUgLyo/Ki8gaGludCIKY2FzZSBDLmZSOnJldHVybiJSZW1vdmUgLyohKi8g
+aGludCIKY2FzZSBDLm15OnJldHVybiJDaGFuZ2UgdG8gLyo/Ki8gaGludCIKY2FzZSBDLnJ4OnJldHVy
+biJDaGFuZ2UgdG8gLyohKi8gaGludCJ9cmV0dXJuIG51bGx9LApMTDpmdW5jdGlvbiBMTChhLGIpe3Ro
+aXMuYT1hCnRoaXMuYj1ifSwKTUQ6ZnVuY3Rpb24gTUQoYSl7dGhpcy5hPWF9LApINzpmdW5jdGlvbiBI
+NyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifX0sTT17CllGOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAs
+byxuLG0sbApmb3Iocz1iLmxlbmd0aCxyPTE7cjxzOysrcil7aWYoYltyXT09bnVsbHx8YltyLTFdIT1u
+dWxsKWNvbnRpbnVlCmZvcig7cz49MTtzPXEpe3E9cy0xCmlmKGJbcV0hPW51bGwpYnJlYWt9cD1uZXcg
+UC5SbigiIikKbz1hKyIoIgpwLmE9bwpuPUgudDYoYikKbT1uLkMoIm5IPDE+IikKbD1uZXcgSC5uSChi
+LDAscyxtKQpsLkhkKGIsMCxzLG4uYykKbT1vK25ldyBILmxKKGwsbS5DKCJxVShhTC5FKSIpLmEobmV3
+IE0uTm8oKSksbS5DKCJsSjxhTC5FLHFVPiIpKS5rKDAsIiwgIikKcC5hPW0KcC5hPW0rKCIpOiBwYXJ0
+ICIrKHItMSkrIiB3YXMgbnVsbCwgYnV0IHBhcnQgIityKyIgd2FzIG5vdC4iKQp0aHJvdyBILmIoUC54
+WShwLncoMCkpKX19LApsSTpmdW5jdGlvbiBsSShhKXt0aGlzLmE9YX0sCnE3OmZ1bmN0aW9uIHE3KCl7
+fSwKTm86ZnVuY3Rpb24gTm8oKXt9fSxYPXsKQ0w6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG49
+Yi54WihhKQpiLmhLKGEpCmlmKG4hPW51bGwpYT1KLktWKGEsbi5sZW5ndGgpCnM9dC5zCnI9SC5WTShb
+XSxzKQpxPUguVk0oW10scykKcz1hLmxlbmd0aAppZihzIT09MCYmYi5yNChDLnhCLlcoYSwwKSkpe2lm
+KDA+PXMpcmV0dXJuIEguT0goYSwwKQpDLk5tLmkocSxhWzBdKQpwPTF9ZWxzZXtDLk5tLmkocSwiIikK
+cD0wfWZvcihvPXA7bzxzOysrbylpZihiLnI0KEMueEIuVyhhLG8pKSl7Qy5ObS5pKHIsQy54Qi5Oaihh
+LHAsbykpCkMuTm0uaShxLGFbb10pCnA9bysxfWlmKHA8cyl7Qy5ObS5pKHIsQy54Qi55bihhLHApKQpD
+Lk5tLmkocSwiIil9cmV0dXJuIG5ldyBYLldEKGIsbixyLHEpfSwKV0Q6ZnVuY3Rpb24gV0QoYSxiLGMs
+ZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9YwpfLmU9ZH0sCkk3OmZ1bmN0aW9uKGEpe3JldHVy
+biBuZXcgWC5kdihhKX0sCmR2OmZ1bmN0aW9uIGR2KGEpe3RoaXMuYT1hfX0sTz17ClJoOmZ1bmN0aW9u
+KCl7dmFyIHMscj1udWxsCmlmKFAudW8oKS5nRmkoKSE9PSJmaWxlIilyZXR1cm4gJC5FYigpCnM9UC51
+bygpCmlmKCFDLnhCLlRjKHMuZ0lpKHMpLCIvIikpcmV0dXJuICQuRWIoKQppZihQLktMKHIsImEvYiIs
+cixyLHIscixyKS50NCgpPT09ImFcXGIiKXJldHVybiAkLktrKCkKcmV0dXJuICQuYkQoKX0sCnpMOmZ1
+bmN0aW9uIHpMKCl7fX0sRT17T0Y6ZnVuY3Rpb24gT0YoYSxiLGMpe3RoaXMuZD1hCnRoaXMuZT1iCnRo
+aXMuZj1jfX0sRj17cnU6ZnVuY3Rpb24gcnUoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmQ9YQpfLmU9Ygpf
+LmY9YwpfLnI9ZH19LEQ9ewphYjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89bnVsbAp0cnl7bz1QLnVv
+KCl9Y2F0Y2gocyl7aWYodC5nOC5iKEguUnUocykpKXtyPSQuRmYKaWYociE9bnVsbClyZXR1cm4gcgp0
+aHJvdyBzfWVsc2UgdGhyb3cgc31pZihKLlJNKG8sJC5JNikpe3I9JC5GZgpyLnRvU3RyaW5nCnJldHVy
+biByfSQuSTY9bwppZigkLkhrKCk9PSQuRWIoKSlyPSQuRmY9by5aSSgiLiIpLncoMCkKZWxzZXtxPW8u
+dDQoKQpwPXEubGVuZ3RoLTEKcj0kLkZmPXA9PT0wP3E6Qy54Qi5OaihxLDAscCl9ci50b1N0cmluZwpy
+ZXR1cm4gcn19CnZhciB3PVtDLEgsSixQLFcsVSxCLFQsTCxSLE0sWCxPLEUsRixEXQpodW5rSGVscGVy
+cy5zZXRGdW5jdGlvbk5hbWVzSWZOZWNlc3NhcnkodykKdmFyICQ9e30KSC5GSy5wcm90b3R5cGU9e30K
+Si5Hdi5wcm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe3JldHVybiBhPT09Yn0sCmdpTzpmdW5jdGlv
+bihhKXtyZXR1cm4gSC5lUShhKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0gu
+RWooSC5NKGEpKSsiJyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKGEs
+Yi5nV2EoKSxiLmduZCgpLGIuZ1ZtKCkpKX19CkoueUUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXty
+ZXR1cm4gU3RyaW5nKGEpfSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBhPzUxOTAxODoyMTgxNTl9LAok
+aWEyOjF9Ckoud2UucHJvdG90eXBlPXsKRE46ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbnVsbD09Yn0sCnc6
+ZnVuY3Rpb24oYSl7cmV0dXJuIm51bGwifSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiAwfSwKZTc6ZnVu
+Y3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5TaihhLHQuby5hKGIpKX0sCiRpYzg6MX0KSi5NRi5wcm90b3R5
+cGU9ewpnaU86ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmco
+YSl9LAokaXZtOjF9CkouaUMucHJvdG90eXBlPXt9Ckoua2QucHJvdG90eXBlPXt9CkouYzUucHJvdG90
+eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz1hWyQudygpXQppZihzPT1udWxsKXJldHVybiB0aGlzLnQo
+YSkKcmV0dXJuIkphdmFTY3JpcHQgZnVuY3Rpb24gZm9yICIrSC5FaihKLmoocykpfSwKJGlFSDoxfQpK
+LmpkLnByb3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILmpWKGEsSC50NihhKS5D
+KCJAPDE+IikuS3EoYikuQygialY8MSwyPiIpKX0sCmk6ZnVuY3Rpb24oYSxiKXtILnQ2KGEpLmMuYShi
+KQppZighIWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJhZGQiKSkKYS5wdXNoKGIpfSwKVzQ6ZnVuY3Rp
+b24oYSxiKXt2YXIgcwppZighIWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJyZW1vdmVBdCIpKQpzPWEu
+bGVuZ3RoCmlmKGI+PXMpdGhyb3cgSC5iKFAuTzcoYixudWxsKSkKcmV0dXJuIGEuc3BsaWNlKGIsMSlb
+MF19LApVRzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscgpILnQ2KGEpLkMoImNYPDE+IikuYShjKQppZigh
+IWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJpbnNlcnRBbGwiKSkKUC53QShiLDAsYS5sZW5ndGgsImlu
+ZGV4IikKaWYoIXQuZC5iKGMpKWM9Si5SWChjKQpzPUouSG0oYykKYS5sZW5ndGg9YS5sZW5ndGgrcwpy
+PWIrcwp0aGlzLllXKGEscixhLmxlbmd0aCxhLGIpCnRoaXMudmcoYSxiLHIsYyl9LApGVjpmdW5jdGlv
+bihhLGIpe3ZhciBzCkgudDYoYSkuQygiY1g8MT4iKS5hKGIpCmlmKCEhYS5maXhlZCRsZW5ndGgpSC52
+KFAuTDQoImFkZEFsbCIpKQppZihBcnJheS5pc0FycmF5KGIpKXt0aGlzLktoKGEsYikKcmV0dXJufWZv
+cihzPUouSVQoYik7cy5GKCk7KWEucHVzaChzLmdsKCkpfSwKS2g6ZnVuY3Rpb24oYSxiKXt2YXIgcyxy
+CnQuYi5hKGIpCnM9Yi5sZW5ndGgKaWYocz09PTApcmV0dXJuCmlmKGE9PT1iKXRocm93IEguYihQLmE0
+KGEpKQpmb3Iocj0wO3I8czsrK3IpYS5wdXNoKGJbcl0pfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBz
+PUgudDYoYSkKcmV0dXJuIG5ldyBILmxKKGEscy5LcShjKS5DKCIxKDIpIikuYShiKSxzLkMoIkA8MT4i
+KS5LcShjKS5DKCJsSjwxLDI+IikpfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHI9UC5POChhLmxlbmd0
+aCwiIiwhMSx0Lk4pCmZvcihzPTA7czxhLmxlbmd0aDsrK3MpdGhpcy5ZNShyLHMsSC5FaihhW3NdKSkK
+cmV0dXJuIHIuam9pbihiKX0sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEgucUMoYSxiLG51bGwsSC50
+NihhKS5jKX0sCk4wOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQpkLmEoYikKSC50NihhKS5LcShk
+KS5DKCIxKDEsMikiKS5hKGMpCnM9YS5sZW5ndGgKZm9yKHI9YixxPTA7cTxzOysrcSl7cj1jLiQyKHIs
+YVtxXSkKaWYoYS5sZW5ndGghPT1zKXRocm93IEguYihQLmE0KGEpKX1yZXR1cm4gcn0sCkh0OmZ1bmN0
+aW9uKGEsYil7dmFyIHMscixxLHAsbwpILnQ2KGEpLkMoImEyKDEpIikuYShiKQpzPWEubGVuZ3RoCmZv
+cihyPW51bGwscT0hMSxwPTA7cDxzOysrcCl7bz1hW3BdCmlmKEgub1QoYi4kMShvKSkpe2lmKHEpdGhy
+b3cgSC5iKEguQW0oKSkKcj1vCnE9ITB9aWYocyE9PWEubGVuZ3RoKXRocm93IEguYihQLmE0KGEpKX1p
+ZihxKXJldHVybiByCnRocm93IEguYihILldwKCkpfSwKRTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49
+YS5sZW5ndGgpcmV0dXJuIEguT0goYSxiKQpyZXR1cm4gYVtiXX0sCmd0SDpmdW5jdGlvbihhKXtpZihh
+Lmxlbmd0aD4wKXJldHVybiBhWzBdCnRocm93IEguYihILldwKCkpfSwKZ3JaOmZ1bmN0aW9uKGEpe3Zh
+ciBzPWEubGVuZ3RoCmlmKHM+MClyZXR1cm4gYVtzLTFdCnRocm93IEguYihILldwKCkpfSwKWVc6ZnVu
+Y3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvCkgudDYoYSkuQygiY1g8MT4iKS5hKGQpCmlmKCEh
+YS5pbW11dGFibGUkbGlzdClILnYoUC5MNCgic2V0UmFuZ2UiKSkKUC5qQihiLGMsYS5sZW5ndGgpCnM9
+Yy1iCmlmKHM9PT0wKXJldHVybgpQLmsxKGUsInNraXBDb3VudCIpCmlmKHQuai5iKGQpKXtyPWQKcT1l
+fWVsc2V7cj1KLkE1KGQsZSkudHQoMCwhMSkKcT0wfXA9Si5VNihyKQppZihxK3M+cC5nQShyKSl0aHJv
+dyBILmIoSC5hcigpKQppZihxPGIpZm9yKG89cy0xO28+PTA7LS1vKWFbYitvXT1wLnEocixxK28pCmVs
+c2UgZm9yKG89MDtvPHM7KytvKWFbYitvXT1wLnEocixxK28pfSwKdmc6ZnVuY3Rpb24oYSxiLGMsZCl7
+cmV0dXJuIHRoaXMuWVcoYSxiLGMsZCwwKX0sClZyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILnQ2KGEp
+LkMoImEyKDEpIikuYShiKQpzPWEubGVuZ3RoCmZvcihyPTA7cjxzOysrcil7aWYoSC5vVChiLiQxKGFb
+cl0pKSlyZXR1cm4hMAppZihhLmxlbmd0aCE9PXMpdGhyb3cgSC5iKFAuYTQoYSkpfXJldHVybiExfSwK
+dGc6ZnVuY3Rpb24oYSxiKXt2YXIgcwpmb3Iocz0wO3M8YS5sZW5ndGg7KytzKWlmKEouUk0oYVtzXSxi
+KSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGg9PT0wfSwK
+Z29yOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aCE9PTB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQ
+LldFKGEsIlsiLCJdIil9LAp0dDpmdW5jdGlvbihhLGIpe3ZhciBzPUguVk0oYS5zbGljZSgwKSxILnQ2
+KGEpKQpyZXR1cm4gc30sCmJyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnR0KGEsITApfSwKZ206ZnVu
+Y3Rpb24oYSl7cmV0dXJuIG5ldyBKLm0xKGEsYS5sZW5ndGgsSC50NihhKS5DKCJtMTwxPiIpKX0sCmdp
+TzpmdW5jdGlvbihhKXtyZXR1cm4gSC5lUShhKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0
+aH0sCnNBOmZ1bmN0aW9uKGEsYil7aWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgic2V0IGxlbmd0
+aCIpKQppZihiPDApdGhyb3cgSC5iKFAuVEUoYiwwLG51bGwsIm5ld0xlbmd0aCIsbnVsbCkpCmEubGVu
+Z3RoPWJ9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93IEgu
+YihILkhZKGEsYikpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe0gudDYoYSkuYy5hKGMp
+CmlmKCEhYS5pbW11dGFibGUkbGlzdClILnYoUC5MNCgiaW5kZXhlZCBzZXQiKSkKaWYoYj49YS5sZW5n
+dGh8fGI8MCl0aHJvdyBILmIoSC5IWShhLGIpKQphW2JdPWN9LAokaWJROjEsCiRpY1g6MSwKJGl6TTox
+fQpKLlBvLnByb3RvdHlwZT17fQpKLm0xLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRo
+aXMuZH0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLmEscD1xLmxlbmd0aAppZihyLmIhPT1w
+KXRocm93IEguYihILmxrKHEpKQpzPXIuYwppZihzPj1wKXtyLnNNKG51bGwpCnJldHVybiExfXIuc00o
+cVtzXSk7KytyLmMKcmV0dXJuITB9LApzTTpmdW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8i
+KS5hKGEpfSwKJGlBbjoxfQpKLnFJLnByb3RvdHlwZT17CnpROmZ1bmN0aW9uKGEpe2lmKGE+MCl7aWYo
+YSE9PTEvMClyZXR1cm4gTWF0aC5yb3VuZChhKX1lbHNlIGlmKGE+LTEvMClyZXR1cm4gMC1NYXRoLnJv
+dW5kKDAtYSkKdGhyb3cgSC5iKFAuTDQoIiIrYSsiLnJvdW5kKCkiKSl9LAp3OmZ1bmN0aW9uKGEpe2lm
+KGE9PT0wJiYxL2E8MClyZXR1cm4iLTAuMCIKZWxzZSByZXR1cm4iIithfSwKZ2lPOmZ1bmN0aW9uKGEp
+e3ZhciBzLHIscSxwLG89YXwwCmlmKGE9PT1vKXJldHVybiBvJjUzNjg3MDkxMQpzPU1hdGguYWJzKGEp
+CnI9TWF0aC5sb2cocykvMC42OTMxNDcxODA1NTk5NDUzfDAKcT1NYXRoLnBvdygyLHIpCnA9czwxP3Mv
+cTpxL3MKcmV0dXJuKChwKjkwMDcxOTkyNTQ3NDA5OTJ8MCkrKHAqMzU0MjI0MzE4MTE3NjUyMXwwKSkq
+NTk5MTk3K3IqMTI1OSY1MzY4NzA5MTF9LAp6WTpmdW5jdGlvbihhLGIpe3ZhciBzPWElYgppZihzPT09
+MClyZXR1cm4gMAppZihzPjApcmV0dXJuIHMKaWYoYjwwKXJldHVybiBzLWIKZWxzZSByZXR1cm4gcyti
+fSwKQlU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4oYXwwKT09PWE/YS9ifDA6dGhpcy5ESihhLGIpfSwKREo6
+ZnVuY3Rpb24oYSxiKXt2YXIgcz1hL2IKaWYocz49LTIxNDc0ODM2NDgmJnM8PTIxNDc0ODM2NDcpcmV0
+dXJuIHN8MAppZihzPjApe2lmKHMhPT0xLzApcmV0dXJuIE1hdGguZmxvb3Iocyl9ZWxzZSBpZihzPi0x
+LzApcmV0dXJuIE1hdGguY2VpbChzKQp0aHJvdyBILmIoUC5MNCgiUmVzdWx0IG9mIHRydW5jYXRpbmcg
+ZGl2aXNpb24gaXMgIitILkVqKHMpKyI6ICIrSC5FaihhKSsiIH4vICIrYikpfSwKd0c6ZnVuY3Rpb24o
+YSxiKXt2YXIgcwppZihhPjApcz10aGlzLnAzKGEsYikKZWxzZXtzPWI+MzE/MzE6YgpzPWE+PnM+Pj4w
+fXJldHVybiBzfSwKYmY6ZnVuY3Rpb24oYSxiKXtpZihiPDApdGhyb3cgSC5iKEgudEwoYikpCnJldHVy
+biB0aGlzLnAzKGEsYil9LApwMzpmdW5jdGlvbihhLGIpe3JldHVybiBiPjMxPzA6YT4+PmJ9LAokaUNQ
+OjEsCiRpWlo6MX0KSi5iVS5wcm90b3R5cGU9eyRpQjI6MX0KSi5WQS5wcm90b3R5cGU9e30KSi5Eci5w
+cm90b3R5cGU9ewpPOmZ1bmN0aW9uKGEsYil7aWYoYjwwKXRocm93IEguYihILkhZKGEsYikpCmlmKGI+
+PWEubGVuZ3RoKUgudihILkhZKGEsYikpCnJldHVybiBhLmNoYXJDb2RlQXQoYil9LApXOmZ1bmN0aW9u
+KGEsYil7aWYoYj49YS5sZW5ndGgpdGhyb3cgSC5iKEguSFkoYSxiKSkKcmV0dXJuIGEuY2hhckNvZGVB
+dChiKX0sCmRkOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILnVuKGIsYSwwKX0sCmg6ZnVuY3Rpb24o
+YSxiKXtpZih0eXBlb2YgYiE9InN0cmluZyIpdGhyb3cgSC5iKFAuTDMoYixudWxsLG51bGwpKQpyZXR1
+cm4gYStifSwKVGM6ZnVuY3Rpb24oYSxiKXt2YXIgcz1iLmxlbmd0aCxyPWEubGVuZ3RoCmlmKHM+cily
+ZXR1cm4hMQpyZXR1cm4gYj09PXRoaXMueW4oYSxyLXMpfSwKaTc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFy
+IHM9UC5qQihiLGMsYS5sZW5ndGgpLHI9YS5zdWJzdHJpbmcoMCxiKSxxPWEuc3Vic3RyaW5nKHMpCnJl
+dHVybiByK2QrcX0sClFpOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhy
+b3cgSC5iKFAuVEUoYywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YytiLmxlbmd0aAppZihzPmEubGVu
+Z3RoKXJldHVybiExCnJldHVybiBiPT09YS5zdWJzdHJpbmcoYyxzKX0sCm46ZnVuY3Rpb24oYSxiKXty
+ZXR1cm4gdGhpcy5RaShhLGIsMCl9LApOajpmdW5jdGlvbihhLGIsYyl7aWYoYz09bnVsbCljPWEubGVu
+Z3RoCmlmKGI8MCl0aHJvdyBILmIoUC5PNyhiLG51bGwpKQppZihiPmMpdGhyb3cgSC5iKFAuTzcoYixu
+dWxsKSkKaWYoYz5hLmxlbmd0aCl0aHJvdyBILmIoUC5PNyhjLG51bGwpKQpyZXR1cm4gYS5zdWJzdHJp
+bmcoYixjKX0sCnluOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuTmooYSxiLG51bGwpfSwKaGM6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIGEudG9Mb3dlckNhc2UoKX0sCmJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxw
+PWEudHJpbSgpLG89cC5sZW5ndGgKaWYobz09PTApcmV0dXJuIHAKaWYodGhpcy5XKHAsMCk9PT0xMzMp
+e3M9Si5tbShwLDEpCmlmKHM9PT1vKXJldHVybiIifWVsc2Ugcz0wCnI9by0xCnE9dGhpcy5PKHAscik9
+PT0xMzM/Si5jMShwLHIpOm8KaWYocz09PTAmJnE9PT1vKXJldHVybiBwCnJldHVybiBwLnN1YnN0cmlu
+ZyhzLHEpfSwKVDpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoMD49YilyZXR1cm4iIgppZihiPT09MXx8
+YS5sZW5ndGg9PT0wKXJldHVybiBhCmlmKGIhPT1iPj4+MCl0aHJvdyBILmIoQy5FcSkKZm9yKHM9YSxy
+PSIiOyEwOyl7aWYoKGImMSk9PT0xKXI9cytyCmI9Yj4+PjEKaWYoYj09PTApYnJlYWsKcys9c31yZXR1
+cm4gcn0sClhVOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5i
+KFAuVEUoYywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YS5pbmRleE9mKGIsYykKcmV0dXJuIHN9LApP
+WTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlhVKGEsYiwwKX0sClBrOmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcyxyCmlmKGM9PW51bGwpYz1hLmxlbmd0aAplbHNlIGlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBI
+LmIoUC5URShjLDAsYS5sZW5ndGgsbnVsbCxudWxsKSkKcz1iLmxlbmd0aApyPWEubGVuZ3RoCmlmKGMr
+cz5yKWM9ci1zCnJldHVybiBhLmxhc3RJbmRleE9mKGIsYyl9LApjbjpmdW5jdGlvbihhLGIpe3JldHVy
+biB0aGlzLlBrKGEsYixudWxsKX0sCklzOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1hLmxlbmd0aAppZihj
+PnMpdGhyb3cgSC5iKFAuVEUoYywwLHMsbnVsbCxudWxsKSkKcmV0dXJuIEguU1EoYSxiLGMpfSwKdGc6
+ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5JcyhhLGIsMCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBh
+fSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1hLmxlbmd0aCxyPTAscT0wO3E8czsrK3Ep
+e3I9cithLmNoYXJDb2RlQXQocSkmNTM2ODcwOTExCnI9cisoKHImNTI0Mjg3KTw8MTApJjUzNjg3MDkx
+MQpyXj1yPj42fXI9cisoKHImNjcxMDg4NjMpPDwzKSY1MzY4NzA5MTEKcl49cj4+MTEKcmV0dXJuIHIr
+KChyJjE2MzgzKTw8MTUpJjUzNjg3MDkxMX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0s
+CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+PWEubGVuZ3RofHwhMSl0aHJvdyBILmIoSC5IWShh
+LGIpKQpyZXR1cm4gYVtiXX0sCiRpdlg6MSwKJGlxVToxfQpILkJSLnByb3RvdHlwZT17CmdtOmZ1bmN0
+aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILkU3KEouSVQodGhpcy5nT04oKSkscy5D
+KCJAPDE+IikuS3Eocy5RWzFdKS5DKCJFNzwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEou
+SG0odGhpcy5nT04oKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudVUodGhpcy5nT04oKSl9LApn
+b3I6ZnVuY3Rpb24oYSl7cmV0dXJuIEouRjcodGhpcy5nT04oKSl9LAplUjpmdW5jdGlvbihhLGIpe3Zh
+ciBzPUguTGgodGhpcykKcmV0dXJuIEguR0ooSi5BNSh0aGlzLmdPTigpLGIpLHMuYyxzLlFbMV0pfSwK
+RTpmdW5jdGlvbihhLGIpe3JldHVybiBILkxoKHRoaXMpLlFbMV0uYShKLkdBKHRoaXMuZ09OKCksYikp
+fSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gSi5qKHRoaXMuZ09OKCkpfX0KSC5FNy5wcm90b3R5cGU9ewpG
+OmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5GKCl9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLiR0
+aS5RWzFdLmEodGhpcy5hLmdsKCkpfSwKJGlBbjoxfQpILlp5LnByb3RvdHlwZT17CmdPTjpmdW5jdGlv
+bigpe3JldHVybiB0aGlzLmF9fQpILm9sLnByb3RvdHlwZT17JGliUToxfQpILlVxLnByb3RvdHlwZT17
+CnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy4kdGkuUVsxXS5hKEoueDkodGhpcy5hLEgudVAoYikp
+KX0sClk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz10aGlzLiR0aQpKLnU5KHRoaXMuYSxiLHMuYy5hKHMu
+UVsxXS5hKGMpKSl9LAokaWJROjEsCiRpek06MX0KSC5qVi5wcm90b3R5cGU9ewpkcjpmdW5jdGlvbihh
+LGIpe3JldHVybiBuZXcgSC5qVih0aGlzLmEsdGhpcy4kdGkuQygiQDwxPiIpLktxKGIpLkMoImpWPDEs
+Mj4iKSl9LApnT046ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hfX0KSC5uLnByb3RvdHlwZT17Cnc6ZnVu
+Y3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzIT1udWxsPyJMYXRlSW5pdGlhbGl6YXRpb25FcnJv
+cjogIitzOiJMYXRlSW5pdGlhbGl6YXRpb25FcnJvciJ9fQpILnIzLnByb3RvdHlwZT17Cnc6ZnVuY3Rp
+b24oYSl7dmFyIHM9IlJlYWNoYWJpbGl0eUVycm9yOiAiK3RoaXMuYQpyZXR1cm4gc319CkgucWoucHJv
+dG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEs
+Yil7cmV0dXJuIEMueEIuTyh0aGlzLmEsSC51UChiKSl9fQpILkdNLnByb3RvdHlwZT17Cnc6ZnVuY3Rp
+b24oYSl7cmV0dXJuIk51bGwgaXMgbm90IGEgdmFsaWQgdmFsdWUgZm9yIHRoZSBwYXJhbWV0ZXIgJyIr
+dGhpcy5hKyInIG9mIHR5cGUgJyIrSC5LeCh0aGlzLiR0aS5jKS53KDApKyInIn19CkguYlEucHJvdG90
+eXBlPXt9CkguYUwucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpyZXR1cm4gbmV3
+IEguYTcocyxzLmdBKHMpLEguTGgocykuQygiYTc8YUwuRT4iKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0
+dXJuIHRoaXMuZ0EodGhpcyk9PT0wfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPXRoaXMsbz1w
+LmdBKHApCmlmKGIubGVuZ3RoIT09MCl7aWYobz09PTApcmV0dXJuIiIKcz1ILkVqKHAuRSgwLDApKQpp
+ZihvIT09cC5nQShwKSl0aHJvdyBILmIoUC5hNChwKSkKZm9yKHI9cyxxPTE7cTxvOysrcSl7cj1yK2Ir
+SC5FaihwLkUoMCxxKSkKaWYobyE9PXAuZ0EocCkpdGhyb3cgSC5iKFAuYTQocCkpfXJldHVybiByLmNo
+YXJDb2RlQXQoMCk9PTA/cjpyfWVsc2V7Zm9yKHE9MCxyPSIiO3E8bzsrK3Epe3IrPUguRWoocC5FKDAs
+cSkpCmlmKG8hPT1wLmdBKHApKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gci5jaGFyQ29kZUF0KDAp
+PT0wP3I6cn19LApldjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLkdHKDAsSC5MaCh0aGlzKS5DKCJh
+MihhTC5FKSIpLmEoYikpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0dXJu
+IG5ldyBILmxKKHRoaXMscy5LcShjKS5DKCIxKGFMLkUpIikuYShiKSxzLkMoIkA8YUwuRT4iKS5LcShj
+KS5DKCJsSjwxLDI+IikpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5xQyh0aGlzLGIsbnVsbCxI
+LkxoKHRoaXMpLkMoImFMLkUiKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVybiBQLlkxKHRoaXMsITAs
+SC5MaCh0aGlzKS5DKCJhTC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9
+fQpILm5ILnByb3RvdHlwZT17CkhkOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9dGhpcy5iClAuazEo
+ciwic3RhcnQiKQpzPXRoaXMuYwppZihzIT1udWxsKXtQLmsxKHMsImVuZCIpCmlmKHI+cyl0aHJvdyBI
+LmIoUC5URShyLDAscywic3RhcnQiLG51bGwpKX19LApnVUQ6ZnVuY3Rpb24oKXt2YXIgcz1KLkhtKHRo
+aXMuYSkscj10aGlzLmMKaWYocj09bnVsbHx8cj5zKXJldHVybiBzCnJldHVybiByfSwKZ0FzOmZ1bmN0
+aW9uKCl7dmFyIHM9Si5IbSh0aGlzLmEpLHI9dGhpcy5iCmlmKHI+cylyZXR1cm4gcwpyZXR1cm4gcn0s
+CmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9Si5IbSh0aGlzLmEpLHE9dGhpcy5iCmlmKHE+PXIpcmV0dXJu
+IDAKcz10aGlzLmMKaWYocz09bnVsbHx8cz49cilyZXR1cm4gci1xCmlmKHR5cGVvZiBzIT09Im51bWJl
+ciIpcmV0dXJuIHMuSE4oKQpyZXR1cm4gcy1xfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMscj1z
+LmdBcygpK2IKaWYoYjwwfHxyPj1zLmdVRCgpKXRocm93IEguYihQLkNmKGIscywiaW5kZXgiLG51bGws
+bnVsbCkpCnJldHVybiBKLkdBKHMuYSxyKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMK
+UC5rMShiLCJjb3VudCIpCnM9cS5iK2IKcj1xLmMKaWYociE9bnVsbCYmcz49cilyZXR1cm4gbmV3IEgu
+TUIocS4kdGkuQygiTUI8MT4iKSkKcmV0dXJuIEgucUMocS5hLHMscixxLiR0aS5jKX0sCnR0OmZ1bmN0
+aW9uKGEsYil7dmFyIHMscixxLHA9dGhpcyxvPXAuYixuPXAuYSxtPUouVTYobiksbD1tLmdBKG4pLGs9
+cC5jCmlmKGshPW51bGwmJms8bClsPWsKaWYodHlwZW9mIGwhPT0ibnVtYmVyIilyZXR1cm4gbC5ITigp
+CnM9bC1vCmlmKHM8PTApe249Si5RaSgwLHAuJHRpLmMpCnJldHVybiBufXI9UC5POChzLG0uRShuLG8p
+LCExLHAuJHRpLmMpCmZvcihxPTE7cTxzOysrcSl7Qy5ObS5ZNShyLHEsbS5FKG4sbytxKSkKaWYobS5n
+QShuKTxsKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gcn19CkguYTcucHJvdG90eXBlPXsKZ2w6ZnVu
+Y3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxwPUou
+VTYocSksbz1wLmdBKHEpCmlmKHIuYiE9PW8pdGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM+PW8p
+e3Iuc0kobnVsbCkKcmV0dXJuITF9ci5zSShwLkUocSxzKSk7KytyLmMKcmV0dXJuITB9LApzSTpmdW5j
+dGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpILmkxLnByb3RvdHlw
+ZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILk1IKEouSVQodGhp
+cy5hKSx0aGlzLmIscy5DKCJAPDE+IikuS3Eocy5RWzFdKS5DKCJNSDwxLDI+IikpfSwKZ0E6ZnVuY3Rp
+b24oYSl7cmV0dXJuIEouSG0odGhpcy5hKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlz
+LmEpfSwKRTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmIuJDEoSi5HQSh0aGlzLmEsYikpfX0KSC54
+eS5wcm90b3R5cGU9eyRpYlE6MX0KSC5NSC5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHM9dGhp
+cyxyPXMuYgppZihyLkYoKSl7cy5zSShzLmMuJDEoci5nbCgpKSkKcmV0dXJuITB9cy5zSShudWxsKQpy
+ZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX0sCnNJOmZ1bmN0aW9uKGEpe3RoaXMu
+YT10aGlzLiR0aS5DKCIyPyIpLmEoYSl9fQpILmxKLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBKLkhtKHRoaXMuYSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYi4kMShKLkdBKHRo
+aXMuYSxiKSl9fQpILlU1LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5TTyhK
+LklUKHRoaXMuYSksdGhpcy5iLHRoaXMuJHRpLkMoIlNPPDE+IikpfX0KSC5TTy5wcm90b3R5cGU9ewpG
+OmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLmI7cy5GKCk7KWlmKEgub1Qoci4k
+MShzLmdsKCkpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5n
+bCgpfX0KSC5BTS5wcm90b3R5cGU9ewplUjpmdW5jdGlvbihhLGIpe1AuTVIoYiwiY291bnQiLHQuUykK
+UC5rMShiLCJjb3VudCIpCnJldHVybiBuZXcgSC5BTSh0aGlzLmEsdGhpcy5iK2IsSC5MaCh0aGlzKS5D
+KCJBTTwxPiIpKX0sCmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5VMShKLklUKHRoaXMuYSksdGhp
+cy5iLEguTGgodGhpcykuQygiVTE8MT4iKSl9fQpILmQ1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEp
+e3ZhciBzPUouSG0odGhpcy5hKS10aGlzLmIKaWYocz49MClyZXR1cm4gcwpyZXR1cm4gMH0sCmVSOmZ1
+bmN0aW9uKGEsYil7UC5NUihiLCJjb3VudCIsdC5TKQpQLmsxKGIsImNvdW50IikKcmV0dXJuIG5ldyBI
+LmQ1KHRoaXMuYSx0aGlzLmIrYix0aGlzLiR0aSl9LAokaWJROjF9CkguVTEucHJvdG90eXBlPXsKRjpm
+dW5jdGlvbigpe3ZhciBzLHIKZm9yKHM9dGhpcy5hLHI9MDtyPHRoaXMuYjsrK3Ipcy5GKCkKdGhpcy5i
+PTAKcmV0dXJuIHMuRigpfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmdsKCl9fQpILk1CLnBy
+b3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBDLkd3fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVy
+biEwfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LApFOmZ1bmN0aW9uKGEsYil7dGhyb3cgSC5iKFAu
+VEUoYiwwLDAsImluZGV4IixudWxsKSl9LAplUjpmdW5jdGlvbihhLGIpe1AuazEoYiwiY291bnQiKQpy
+ZXR1cm4gdGhpc319CkguRnUucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3JldHVybiExfSwKZ2w6ZnVu
+Y3Rpb24oKXt0aHJvdyBILmIoSC5XcCgpKX0sCiRpQW46MX0KSC51Ni5wcm90b3R5cGU9ewpnbTpmdW5j
+dGlvbihhKXtyZXR1cm4gbmV3IEguSkIoSi5JVCh0aGlzLmEpLHRoaXMuJHRpLkMoIkpCPDE+IikpfX0K
+SC5KQi5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLiR0
+aS5jO3MuRigpOylpZihyLmIocy5nbCgpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7
+cmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLmEuZ2woKSl9LAokaUFuOjF9CkguU1UucHJvdG90eXBlPXt9
+CkguUmUucHJvdG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe0guTGgodGhpcykuQygiUmUuRSIpLmEo
+YykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgYW4gdW5tb2RpZmlhYmxlIGxpc3QiKSl9fQpI
+LncyLnByb3RvdHlwZT17fQpILnd2LnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlz
+Ll9oYXNoQ29kZQppZihzIT1udWxsKXJldHVybiBzCnM9NjY0NTk3KkouaGYodGhpcy5hKSY1MzY4NzA5
+MTEKdGhpcy5faGFzaENvZGU9cwpyZXR1cm4gc30sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuJ1N5bWJvbCgi
+JytILkVqKHRoaXMuYSkrJyIpJ30sCkROOmZ1bmN0aW9uKGEsYil7aWYoYj09bnVsbClyZXR1cm4hMQpy
+ZXR1cm4gYiBpbnN0YW5jZW9mIEgud3YmJnRoaXMuYT09Yi5hfSwKJGlHRDoxfQpILlFDLnByb3RvdHlw
+ZT17fQpILlBELnByb3RvdHlwZT17fQpILldVLnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1
+cm4gdGhpcy5nQSh0aGlzKT09PTB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLm5PKHRoaXMpfSwKWTU6
+ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcy5jLmEoYikKcy5RWzFdLmEoYykKSC5kYygp
+CkguQmkodS5nKX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5xNChhLEguTGgodGhpcykuQygi
+TjM8MSwyPiIpKX0sCnE0OmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcwpyZXR1cm4gUC5sMChmdW5jdGlv
+bigpe3ZhciByPWEKdmFyIHE9MCxwPTEsbyxuLG0sbCxrCnJldHVybiBmdW5jdGlvbiAkYXN5bmMkZ1B1
+KGMsZCl7aWYoYz09PTEpe289ZApxPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocSl7Y2FzZSAwOm49cy5ndmMo
+KSxuPW4uZ20obiksbT1ILkxoKHMpLG09bS5DKCJAPDE+IikuS3EobS5RWzFdKS5DKCJOMzwxLDI+IikK
+Y2FzZSAyOmlmKCFuLkYoKSl7cT0zCmJyZWFrfWw9bi5nbCgpCms9cy5xKDAsbCkKay50b1N0cmluZwpx
+PTQKcmV0dXJuIG5ldyBQLk4zKGwsayxtKQpjYXNlIDQ6cT0yCmJyZWFrCmNhc2UgMzpyZXR1cm4gUC5U
+aCgpCmNhc2UgMTpyZXR1cm4gUC5ZbShvKX19fSxiKX0sCiRpWjA6MX0KSC5MUC5wcm90b3R5cGU9ewpn
+QTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGEhPSJz
+dHJpbmciKXJldHVybiExCmlmKCJfX3Byb3RvX18iPT09YSlyZXR1cm4hMQpyZXR1cm4gdGhpcy5iLmhh
+c093blByb3BlcnR5KGEpfSwKcTpmdW5jdGlvbihhLGIpe2lmKCF0aGlzLng0KGIpKXJldHVybiBudWxs
+CnJldHVybiB0aGlzLnFQKGIpfSwKcVA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYltILmgoYSldfSwK
+SzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG89SC5MaCh0aGlzKQpvLkMoIn4oMSwyKSIpLmEoYikK
+cz10aGlzLmMKZm9yKHI9cy5sZW5ndGgsbz1vLlFbMV0scT0wO3E8cjsrK3Epe3A9c1txXQpiLiQyKHAs
+by5hKHRoaXMucVAocCkpKX19LApndmM6ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEguWFIodGhpcyxILkxo
+KHRoaXMpLkMoIlhSPDE+IikpfX0KSC5YUi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10
+aGlzLmEuYwpyZXR1cm4gbmV3IEoubTEocyxzLmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfSwKZ0E6
+ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jLmxlbmd0aH19CkguTEkucHJvdG90eXBlPXsKZ1dhOmZ1
+bmN0aW9uKCl7dmFyIHM9dGhpcy5hCnJldHVybiBzfSwKZ25kOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAs
+bz10aGlzCmlmKG8uYz09PTEpcmV0dXJuIEMuaFUKcz1vLmQKcj1zLmxlbmd0aC1vLmUubGVuZ3RoLW8u
+ZgppZihyPT09MClyZXR1cm4gQy5oVQpxPVtdCmZvcihwPTA7cDxyOysrcCl7aWYocD49cy5sZW5ndGgp
+cmV0dXJuIEguT0gocyxwKQpxLnB1c2goc1twXSl9cmV0dXJuIEouekMocSl9LApnVm06ZnVuY3Rpb24o
+KXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhpcwppZihrLmMhPT0wKXJldHVybiBDLldPCnM9ay5lCnI9
+cy5sZW5ndGgKcT1rLmQKcD1xLmxlbmd0aC1yLWsuZgppZihyPT09MClyZXR1cm4gQy5XTwpvPW5ldyBI
+Lk41KHQuZW8pCmZvcihuPTA7bjxyOysrbil7aWYobj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxuKQpt
+PXNbbl0KbD1wK24KaWYobDwwfHxsPj1xLmxlbmd0aClyZXR1cm4gSC5PSChxLGwpCm8uWTUoMCxuZXcg
+SC53dihtKSxxW2xdKX1yZXR1cm4gbmV3IEguUEQobyx0LmdGKX0sCiRpdlE6MX0KSC5Dai5wcm90b3R5
+cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzCkguaChhKQpzPXRoaXMuYQpzLmI9cy5iKyIkIitILkVq
+KGEpCkMuTm0uaSh0aGlzLmIsYSkKQy5ObS5pKHRoaXMuYyxiKTsrK3MuYX0sCiRTOjEzfQpILmY5LnBy
+b3RvdHlwZT17CnFTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9bmV3IFJlZ0V4cChxLmEpLmV4
+ZWMoYSkKaWYocD09bnVsbClyZXR1cm4gbnVsbApzPU9iamVjdC5jcmVhdGUobnVsbCkKcj1xLmIKaWYo
+ciE9PS0xKXMuYXJndW1lbnRzPXBbcisxXQpyPXEuYwppZihyIT09LTEpcy5hcmd1bWVudHNFeHByPXBb
+cisxXQpyPXEuZAppZihyIT09LTEpcy5leHByPXBbcisxXQpyPXEuZQppZihyIT09LTEpcy5tZXRob2Q9
+cFtyKzFdCnI9cS5mCmlmKHIhPT0tMSlzLnJlY2VpdmVyPXBbcisxXQpyZXR1cm4gc319CkguVzAucHJv
+dG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIKaWYocz09bnVsbClyZXR1cm4iTm9TdWNo
+TWV0aG9kRXJyb3I6ICIrSC5Faih0aGlzLmEpCnJldHVybiJOb1N1Y2hNZXRob2RFcnJvcjogbWV0aG9k
+IG5vdCBmb3VuZDogJyIrcysiJyBvbiBudWxsIn19CkguYXoucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
+KXt2YXIgcyxyPXRoaXMscT0iTm9TdWNoTWV0aG9kRXJyb3I6IG1ldGhvZCBub3QgZm91bmQ6ICciLHA9
+ci5iCmlmKHA9PW51bGwpcmV0dXJuIk5vU3VjaE1ldGhvZEVycm9yOiAiK0guRWooci5hKQpzPXIuYwpp
+ZihzPT1udWxsKXJldHVybiBxK3ArIicgKCIrSC5FaihyLmEpKyIpIgpyZXR1cm4gcStwKyInIG9uICci
+K3MrIicgKCIrSC5FaihyLmEpKyIpIn19CkgudlYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIg
+cz10aGlzLmEKcmV0dXJuIHMubGVuZ3RoPT09MD8iRXJyb3IiOiJFcnJvcjogIitzfX0KSC50ZS5wcm90
+b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJUaHJvdyBvZiBudWxsICgnIisodGhpcy5hPT09bnVs
+bD8ibnVsbCI6InVuZGVmaW5lZCIpKyInIGZyb20gSmF2YVNjcmlwdCkifSwKJGlSejoxfQpILmJxLnBy
+b3RvdHlwZT17fQpILlhPLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLmIKaWYo
+ciE9bnVsbClyZXR1cm4gcgpyPXRoaXMuYQpzPXIhPT1udWxsJiZ0eXBlb2Ygcj09PSJvYmplY3QiP3Iu
+c3RhY2s6bnVsbApyZXR1cm4gdGhpcy5iPXM9PW51bGw/IiI6c30sCiRpR3o6MX0KSC5UcC5wcm90b3R5
+cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuY29uc3RydWN0b3Iscj1zPT1udWxsP251bGw6cy5u
+YW1lCnJldHVybiJDbG9zdXJlICciK0guTlEocj09bnVsbD8idW5rbm93biI6cikrIicifSwKJGlFSDox
+LApnS3U6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpc30sCiRDOiIkMSIsCiRSOjEsCiREOm51bGx9CkgubGMu
+cHJvdG90eXBlPXt9CkguengucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiRzdGF0
+aWNfbmFtZQppZihzPT1udWxsKXJldHVybiJDbG9zdXJlIG9mIHVua25vd24gc3RhdGljIG1ldGhvZCIK
+cmV0dXJuIkNsb3N1cmUgJyIrSC5OUShzKSsiJyJ9fQpILnJULnByb3RvdHlwZT17CkROOmZ1bmN0aW9u
+KGEsYil7dmFyIHM9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHM9PT1iKXJldHVybiEwCmlmKCEo
+YiBpbnN0YW5jZW9mIEguclQpKXJldHVybiExCnJldHVybiBzLmE9PT1iLmEmJnMuYj09PWIuYiYmcy5j
+PT09Yi5jfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5jCmlmKHI9PW51bGwpcz1ILmVRKHRo
+aXMuYSkKZWxzZSBzPXR5cGVvZiByIT09Im9iamVjdCI/Si5oZihyKTpILmVRKHIpCnI9SC5lUSh0aGlz
+LmIpCmlmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIHMuWSgpCnJldHVybihzXnIpPj4+MH0sCnc6
+ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCmlmKHM9PW51bGwpcz10aGlzLmEKcmV0dXJuIkNsb3N1cmUg
+JyIrSC5Faih0aGlzLmQpKyInIG9mICIrKCJJbnN0YW5jZSBvZiAnIitILkVqKEguTShzKSkrIiciKX19
+CkguRXEucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iUnVudGltZUVycm9yOiAiK3RoaXMu
+YX19Ckgua1kucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDog
+IitQLnAodGhpcy5hKX19Ckgua3IucHJvdG90eXBlPXt9CkguTjUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rp
+b24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09MH0sCmd2
+YzpmdW5jdGlvbigpe3JldHVybiBuZXcgSC5pNSh0aGlzLEguTGgodGhpcykuQygiaTU8MT4iKSl9LAp4
+NDpmdW5jdGlvbihhKXt2YXIgcyxyCmlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz10aGlzLmIKaWYocz09
+bnVsbClyZXR1cm4hMQpyZXR1cm4gdGhpcy5YdShzLGEpfWVsc2V7cj10aGlzLkNYKGEpCnJldHVybiBy
+fX0sCkNYOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZAppZihzPT1udWxsKXJldHVybiExCnJldHVybiB0
+aGlzLkZoKHRoaXMuQnQocyxKLmhmKGEpJjB4M2ZmZmZmZiksYSk+PTB9LApxOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxLHAsbz10aGlzLG49bnVsbAppZih0eXBlb2YgYj09InN0cmluZyIpe3M9by5iCmlmKHM9
+PW51bGwpcmV0dXJuIG4Kcj1vLmoyKHMsYikKcT1yPT1udWxsP246ci5iCnJldHVybiBxfWVsc2UgaWYo
+dHlwZW9mIGI9PSJudW1iZXIiJiYoYiYweDNmZmZmZmYpPT09Yil7cD1vLmMKaWYocD09bnVsbClyZXR1
+cm4gbgpyPW8uajIocCxiKQpxPXI9PW51bGw/bjpyLmIKcmV0dXJuIHF9ZWxzZSByZXR1cm4gby5hYShi
+KX0sCmFhOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLmQKaWYocT09bnVsbClyZXR1cm4gbnVsbApz
+PXRoaXMuQnQocSxKLmhmKGEpJjB4M2ZmZmZmZikKcj10aGlzLkZoKHMsYSkKaWYocjwwKXJldHVybiBu
+dWxsCnJldHVybiBzW3JdLmJ9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG09dGhp
+cyxsPUguTGgobSkKbC5jLmEoYikKbC5RWzFdLmEoYykKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPW0u
+YgptLkVIKHM9PW51bGw/bS5iPW0ueksoKTpzLGIsYyl9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJlciIm
+JihiJjB4M2ZmZmZmZik9PT1iKXtyPW0uYwptLkVIKHI9PW51bGw/bS5jPW0ueksoKTpyLGIsYyl9ZWxz
+ZXtxPW0uZAppZihxPT1udWxsKXE9bS5kPW0ueksoKQpwPUouaGYoYikmMHgzZmZmZmZmCm89bS5CdChx
+LHApCmlmKG89PW51bGwpbS5FSShxLHAsW20uSG4oYixjKV0pCmVsc2V7bj1tLkZoKG8sYikKaWYobj49
+MClvW25dLmI9YwplbHNlIG8ucHVzaChtLkhuKGIsYykpfX19LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxPXRoaXMKSC5MaChxKS5DKCJ+KDEsMikiKS5hKGIpCnM9cS5lCnI9cS5yCmZvcig7cyE9bnVsbDsp
+e2IuJDIocy5hLHMuYikKaWYociE9PXEucil0aHJvdyBILmIoUC5hNChxKSkKcz1zLmN9fSwKRUg6ZnVu
+Y3Rpb24oYSxiLGMpe3ZhciBzLHI9dGhpcyxxPUguTGgocikKcS5jLmEoYikKcS5RWzFdLmEoYykKcz1y
+LmoyKGEsYikKaWYocz09bnVsbClyLkVJKGEsYixyLkhuKGIsYykpCmVsc2Ugcy5iPWN9LAprczpmdW5j
+dGlvbigpe3RoaXMucj10aGlzLnIrMSY2NzEwODg2M30sCkhuOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhp
+cyxyPUguTGgocykscT1uZXcgSC52aChyLmMuYShhKSxyLlFbMV0uYShiKSkKaWYocy5lPT1udWxsKXMu
+ZT1zLmY9cQplbHNle3I9cy5mCnIudG9TdHJpbmcKcS5kPXIKcy5mPXIuYz1xfSsrcy5hCnMua3MoKQpy
+ZXR1cm4gcX0sCkZoOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZihhPT1udWxsKXJldHVybi0xCnM9YS5s
+ZW5ndGgKZm9yKHI9MDtyPHM7KytyKWlmKEouUk0oYVtyXS5hLGIpKXJldHVybiByCnJldHVybi0xfSwK
+dzpmdW5jdGlvbihhKXtyZXR1cm4gUC5uTyh0aGlzKX0sCmoyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGFb
+Yl19LApCdDpmdW5jdGlvbihhLGIpe3JldHVybiBhW2JdfSwKRUk6ZnVuY3Rpb24oYSxiLGMpe2FbYl09
+Y30sCnJuOmZ1bmN0aW9uKGEsYil7ZGVsZXRlIGFbYl19LApYdTpmdW5jdGlvbihhLGIpe3JldHVybiB0
+aGlzLmoyKGEsYikhPW51bGx9LAp6SzpmdW5jdGlvbigpe3ZhciBzPSI8bm9uLWlkZW50aWZpZXIta2V5
+PiIscj1PYmplY3QuY3JlYXRlKG51bGwpCnRoaXMuRUkocixzLHIpCnRoaXMucm4ocixzKQpyZXR1cm4g
+cn0sCiRpRm86MX0KSC52aC5wcm90b3R5cGU9e30KSC5pNS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihh
+KXtyZXR1cm4gdGhpcy5hLmF9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5hPT09MH0sCmdt
+OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYSxyPW5ldyBILk42KHMscy5yLHRoaXMuJHRpLkMoIk42PDE+
+IikpCnIuYz1zLmUKcmV0dXJuIHJ9LAp0ZzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEueDQoYil9
+fQpILk42LnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rpb24o
+KXt2YXIgcyxyPXRoaXMscT1yLmEKaWYoci5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXIuYwpp
+ZihzPT1udWxsKXtyLnNxWShudWxsKQpyZXR1cm4hMX1lbHNle3Iuc3FZKHMuYSkKci5jPXMuYwpyZXR1
+cm4hMH19LApzcVk6ZnVuY3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46
+MX0KSC5kQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hKGEpfSwKJFM6NH0K
+SC53Ti5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEoYSxiKX0sCiRTOjM0
+fQpILlZYLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEoSC5oKGEpKX0sCiRT
+OjMyfQpILlZSLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlJlZ0V4cC8iK3RoaXMuYSsi
+LyIrdGhpcy5iLmZsYWdzfSwKZ0hjOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYwppZihyIT1udWxs
+KXJldHVybiByCnI9cy5iCnJldHVybiBzLmM9SC52NChzLmEsci5tdWx0aWxpbmUsIXIuaWdub3JlQ2Fz
+ZSxyLnVuaWNvZGUsci5kb3RBbGwsITApfSwKZGQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguS1co
+dGhpcyxiLDApfSwKVVo6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuZ0hjKCkKci5sYXN0SW5kZXg9
+YgpzPXIuZXhlYyhhKQppZihzPT1udWxsKXJldHVybiBudWxsCnJldHVybiBuZXcgSC5FSyhzKX0sCiRp
+dlg6MSwKJGl3TDoxfQpILkVLLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIp
+CnM9dGhpcy5iCmlmKGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHNbYl19LAokaU9k
+OjEsCiRpaWI6MX0KSC5LVy5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguUGIo
+dGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5QYi5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVy
+biB0aGlzLmR9LApGOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPW0uYgppZihsPT1u
+dWxsKXJldHVybiExCnM9bS5jCnI9bC5sZW5ndGgKaWYoczw9cil7cT1tLmEKcD1xLlVaKGwscykKaWYo
+cCE9bnVsbCl7bS5kPXAKcz1wLmIKbz1zLmluZGV4Cm49bytzWzBdLmxlbmd0aAppZihvPT09bil7aWYo
+cS5iLnVuaWNvZGUpe3M9bS5jCnE9cysxCmlmKHE8cil7cz1DLnhCLk8obCxzKQppZihzPj01NTI5NiYm
+czw9NTYzMTkpe3M9Qy54Qi5PKGwscSkKcz1zPj01NjMyMCYmczw9NTczNDN9ZWxzZSBzPSExfWVsc2Ug
+cz0hMX1lbHNlIHM9ITEKbj0ocz9uKzE6bikrMX1tLmM9bgpyZXR1cm4hMH19bS5iPW0uZD1udWxsCnJl
+dHVybiExfSwKJGlBbjoxfQpILnRRLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlm
+KGIhPT0wKUgudihQLk83KGIsbnVsbCkpCnJldHVybiB0aGlzLmN9LAokaU9kOjF9CkgudW4ucHJvdG90
+eXBlPXsKZ206ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBILlNkKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX19
+CkguU2QucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzLHIscT10aGlzLHA9cS5jLG89cS5iLG49
+by5sZW5ndGgsbT1xLmEsbD1tLmxlbmd0aAppZihwK24+bCl7cS5kPW51bGwKcmV0dXJuITF9cz1tLmlu
+ZGV4T2YobyxwKQppZihzPDApe3EuYz1sKzEKcS5kPW51bGwKcmV0dXJuITF9cj1zK24KcS5kPW5ldyBI
+LnRRKHMsbykKcS5jPXI9PT1xLmM/cisxOnIKcmV0dXJuITB9LApnbDpmdW5jdGlvbigpe3ZhciBzPXRo
+aXMuZApzLnRvU3RyaW5nCnJldHVybiBzfSwKJGlBbjoxfQpILkVULnByb3RvdHlwZT17JGlFVDoxLCRp
+QVM6MX0KSC5MWi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LAokaVhq
+OjF9CkguRGcucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5n
+dGgpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe0guR0goYykKSC5vZChiLGEsYS5sZW5n
+dGgpCmFbYl09Y30sCiRpYlE6MSwKJGljWDoxLAokaXpNOjF9CkguUGcucHJvdG90eXBlPXsKWTU6ZnVu
+Y3Rpb24oYSxiLGMpe0gudVAoYykKSC5vZChiLGEsYS5sZW5ndGgpCmFbYl09Y30sCiRpYlE6MSwKJGlj
+WDoxLAokaXpNOjF9CkgueGoucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChi
+LGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kRS5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7
+SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILlpBLnByb3RvdHlwZT17CnE6
+ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVtiXX19CkguZFQu
+cHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVy
+biBhW2JdfX0KSC5QcS5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxh
+Lmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILmVFLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVy
+biBhLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1
+cm4gYVtiXX19CkguVjYucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwK
+cTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfSwKJGlW
+NjoxLAokaW42OjF9CkguUkcucHJvdG90eXBlPXt9CkguVlAucHJvdG90eXBlPXt9CkguV0IucHJvdG90
+eXBlPXt9CkguWkcucHJvdG90eXBlPXt9CkguSmMucHJvdG90eXBlPXsKQzpmdW5jdGlvbihhKXtyZXR1
+cm4gSC5jRSh2LnR5cGVVbml2ZXJzZSx0aGlzLGEpfSwKS3E6ZnVuY3Rpb24oYSl7cmV0dXJuIEgudjUo
+di50eXBlVW5pdmVyc2UsdGhpcyxhKX19CkguRy5wcm90b3R5cGU9e30KSC5sWS5wcm90b3R5cGU9ewp3
+OmZ1bmN0aW9uKGEpe3JldHVybiBILmRtKHRoaXMuYSxudWxsKX19Ckgua1MucHJvdG90eXBlPXsKdzpm
+dW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfX0KSC5pTS5wcm90b3R5cGU9e30KUC50aC5wcm90b3R5cGU9
+ewokMTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEscj1zLmEKcy5hPW51bGwKci4kMCgpfSwKJFM6MTB9
+ClAuaGEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscgp0aGlzLmEuYT10Lk0uYShhKQpz
+PXRoaXMuYgpyPXRoaXMuYwpzLmZpcnN0Q2hpbGQ/cy5yZW1vdmVDaGlsZChyKTpzLmFwcGVuZENoaWxk
+KHIpfSwKJFM6NTJ9ClAuVnMucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuJDAoKX0sCiRD
+OiIkMCIsCiRSOjAsCiRTOjJ9ClAuRnQucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmEuJDAo
+KX0sCiRDOiIkMCIsCiRSOjAsCiRTOjJ9ClAuVzMucHJvdG90eXBlPXsKQ1k6ZnVuY3Rpb24oYSxiKXtp
+ZihzZWxmLnNldFRpbWVvdXQhPW51bGwpc2VsZi5zZXRUaW1lb3V0KEgudFIobmV3IFAueUgodGhpcyxi
+KSwwKSxhKQplbHNlIHRocm93IEguYihQLkw0KCJgc2V0VGltZW91dCgpYCBub3QgZm91bmQuIikpfX0K
+UC55SC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYi4kMCgpfSwKJEM6IiQwIiwKJFI6MCwK
+JFM6MH0KUC5paC5wcm90b3R5cGU9ewphTTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcyxxPXIuJHRp
+CnEuQygiMS8/IikuYShiKQppZighci5iKXIuYS5YZihiKQplbHNle3M9ci5hCmlmKHEuQygiYjg8MT4i
+KS5iKGIpKXMuY1UoYikKZWxzZSBzLlgyKHEuYy5hKGIpKX19LAp3MDpmdW5jdGlvbihhLGIpe3ZhciBz
+CmlmKGI9PW51bGwpYj1QLnYwKGEpCnM9dGhpcy5hCmlmKHRoaXMuYilzLlpMKGEsYikKZWxzZSBzLk5r
+KGEsYil9fQpQLldNLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuJDIoMCxh
+KX0sCiRTOjQzfQpQLlNYLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5hLiQyKDEsbmV3
+IEguYnEoYSx0LmwuYShiKSkpfSwKJEM6IiQyIiwKJFI6MiwKJFM6NTR9ClAuR3MucHJvdG90eXBlPXsK
+JDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEoSC51UChhKSxiKX0sCiRTOjI0fQpQLkZ5LnByb3RvdHlwZT17
+Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkl0ZXJhdGlvbk1hcmtlcigiK3RoaXMuYisiLCAiK0guRWoodGhp
+cy5hKSsiKSJ9fQpQLkdWLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5jCmlmKHM9
+PW51bGwpcmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLmIpCnJldHVybiBzLmdsKCl9LApGOmZ1bmN0aW9u
+KCl7dmFyIHMscixxLHAsbyxuLG09dGhpcwpmb3Iocz1tLiR0aS5DKCJBbjwxPiIpOyEwOyl7cj1tLmMK
+aWYociE9bnVsbClpZihyLkYoKSlyZXR1cm4hMAplbHNlIG0uc1g5KG51bGwpCnE9ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBsLGs9Ygp3aGlsZSh0cnVlKXRyeXtyZXR1cm4gYShrLGwpfWNhdGNoKGope2w9agprPWN9
+fShtLmEsMCwxKQppZihxIGluc3RhbmNlb2YgUC5GeSl7cD1xLmIKaWYocD09PTIpe289bS5kCmlmKG89
+PW51bGx8fG8ubGVuZ3RoPT09MCl7bS5zRUMobnVsbCkKcmV0dXJuITF9aWYoMD49by5sZW5ndGgpcmV0
+dXJuIEguT0gobywtMSkKbS5hPW8ucG9wKCkKY29udGludWV9ZWxzZXtyPXEuYQppZihwPT09Myl0aHJv
+dyByCmVsc2V7bj1zLmEoSi5JVChyKSkKaWYobiBpbnN0YW5jZW9mIFAuR1Ype3I9bS5kCmlmKHI9PW51
+bGwpcj1tLmQ9W10KQy5ObS5pKHIsbS5hKQptLmE9bi5hCmNvbnRpbnVlfWVsc2V7bS5zWDkobikKY29u
+dGludWV9fX19ZWxzZXttLnNFQyhxKQpyZXR1cm4hMH19cmV0dXJuITF9LApzRUM6ZnVuY3Rpb24oYSl7
+dGhpcy5iPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCnNYOTpmdW5jdGlvbihhKXt0aGlzLmM9dGhpcy4k
+dGkuQygiQW48MT4/IikuYShhKX0sCiRpQW46MX0KUC5xNC5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihh
+KXtyZXR1cm4gbmV3IFAuR1YodGhpcy5hKCksdGhpcy4kdGkuQygiR1Y8MT4iKSl9fQpQLkN3LnByb3Rv
+dHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIEguRWoodGhpcy5hKX0sCiRpWFM6MSwKZ0lJOmZ1bmN0
+aW9uKCl7cmV0dXJuIHRoaXMuYn19ClAuUGYucHJvdG90eXBlPXsKdzA6ZnVuY3Rpb24oYSxiKXt2YXIg
+cwpILmNiKGEsImVycm9yIix0LkspCnM9dGhpcy5hCmlmKHMuYSE9PTApdGhyb3cgSC5iKFAuUFYoIkZ1
+dHVyZSBhbHJlYWR5IGNvbXBsZXRlZCIpKQppZihiPT1udWxsKWI9UC52MChhKQpzLk5rKGEsYil9LApw
+bTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy53MChhLG51bGwpfX0KUC5aZi5wcm90b3R5cGU9ewphTTpm
+dW5jdGlvbihhLGIpe3ZhciBzLHI9dGhpcy4kdGkKci5DKCIxLz8iKS5hKGIpCnM9dGhpcy5hCmlmKHMu
+YSE9PTApdGhyb3cgSC5iKFAuUFYoIkZ1dHVyZSBhbHJlYWR5IGNvbXBsZXRlZCIpKQpzLlhmKHIuQygi
+MS8iKS5hKGIpKX19ClAuRmUucHJvdG90eXBlPXsKSFI6ZnVuY3Rpb24oYSl7aWYoKHRoaXMuYyYxNSkh
+PT02KXJldHVybiEwCnJldHVybiB0aGlzLmIuYi5idih0LmFsLmEodGhpcy5kKSxhLmEsdC55LHQuSyl9
+LApLdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmUscj10LnoscT10LksscD10aGlzLiR0aS5DKCIyLyIp
+LG89dGhpcy5iLmIKaWYodC5hZy5iKHMpKXJldHVybiBwLmEoby5ycChzLGEuYSxhLmIscixxLHQubCkp
+CmVsc2UgcmV0dXJuIHAuYShvLmJ2KHQuYkkuYShzKSxhLmEscixxKSl9fQpQLnZzLnByb3RvdHlwZT17
+ClNxOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscD10aGlzLiR0aQpwLktxKGMpLkMoIjEvKDIpIiku
+YShhKQpzPSQuWDMKaWYocyE9PUMuTlUpe2MuQygiQDwwLz4iKS5LcShwLmMpLkMoIjEoMikiKS5hKGEp
+CmlmKGIhPW51bGwpYj1QLlZIKGIscyl9cj1uZXcgUC52cyhzLGMuQygidnM8MD4iKSkKcT1iPT1udWxs
+PzE6Mwp0aGlzLnhmKG5ldyBQLkZlKHIscSxhLGIscC5DKCJAPDE+IikuS3EoYykuQygiRmU8MSwyPiIp
+KSkKcmV0dXJuIHJ9LApXNzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLlNxKGEsbnVsbCxiKX0sClFk
+OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyPXRoaXMuJHRpCnIuS3EoYykuQygiMS8oMikiKS5hKGEpCnM9
+bmV3IFAudnMoJC5YMyxjLkMoInZzPDA+IikpCnRoaXMueGYobmV3IFAuRmUocywxOSxhLGIsci5DKCJA
+PDE+IikuS3EoYykuQygiRmU8MSwyPiIpKSkKcmV0dXJuIHN9LAp4ZjpmdW5jdGlvbihhKXt2YXIgcyxy
+PXRoaXMscT1yLmEKaWYocTw9MSl7YS5hPXQuRi5hKHIuYykKci5jPWF9ZWxzZXtpZihxPT09Mil7cz10
+LmMuYShyLmMpCnE9cy5hCmlmKHE8NCl7cy54ZihhKQpyZXR1cm59ci5hPXEKci5jPXMuY31QLlRrKG51
+bGwsbnVsbCxyLmIsdC5NLmEobmV3IFAuZGEocixhKSkpfX0sCmpROmZ1bmN0aW9uKGEpe3ZhciBzLHIs
+cSxwLG8sbixtPXRoaXMsbD17fQpsLmE9YQppZihhPT1udWxsKXJldHVybgpzPW0uYQppZihzPD0xKXty
+PXQuRi5hKG0uYykKbS5jPWEKaWYociE9bnVsbCl7cT1hLmEKZm9yKHA9YTtxIT1udWxsO3A9cSxxPW8p
+bz1xLmEKcC5hPXJ9fWVsc2V7aWYocz09PTIpe249dC5jLmEobS5jKQpzPW4uYQppZihzPDQpe24ualEo
+YSkKcmV0dXJufW0uYT1zCm0uYz1uLmN9bC5hPW0uTjgoYSkKUC5UayhudWxsLG51bGwsbS5iLHQuTS5h
+KG5ldyBQLm9RKGwsbSkpKX19LAphaDpmdW5jdGlvbigpe3ZhciBzPXQuRi5hKHRoaXMuYykKdGhpcy5j
+PW51bGwKcmV0dXJuIHRoaXMuTjgocyl9LApOODpmdW5jdGlvbihhKXt2YXIgcyxyLHEKZm9yKHM9YSxy
+PW51bGw7cyE9bnVsbDtyPXMscz1xKXtxPXMuYQpzLmE9cn1yZXR1cm4gcn0sCmVjOmZ1bmN0aW9uKGEp
+e3ZhciBzLHIscSxwPXRoaXMKcC5hPTEKdHJ5e2EuU3EobmV3IFAucFYocCksbmV3IFAuVTcocCksdC5Q
+KX1jYXRjaChxKXtzPUguUnUocSkKcj1ILnRzKHEpClAucmIobmV3IFAudnIocCxzLHIpKX19LApYMjpm
+dW5jdGlvbihhKXt2YXIgcyxyPXRoaXMKci4kdGkuYy5hKGEpCnM9ci5haCgpCnIuYT00CnIuYz1hClAu
+SFoocixzKX0sClpMOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKdC5sLmEoYikKcz1xLmFoKCkK
+cj1QLlRsKGEsYikKcS5hPTgKcS5jPXIKUC5IWihxLHMpfSwKWGY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhp
+cy4kdGkKcy5DKCIxLyIpLmEoYSkKaWYocy5DKCJiODwxPiIpLmIoYSkpe3RoaXMuY1UoYSkKcmV0dXJu
+fXRoaXMud1Uocy5jLmEoYSkpfSwKd1U6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpzLiR0aS5jLmEoYSkK
+cy5hPTEKUC5UayhudWxsLG51bGwscy5iLHQuTS5hKG5ldyBQLnJ0KHMsYSkpKX0sCmNVOmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMscj1zLiR0aQpyLkMoImI4PDE+IikuYShhKQppZihyLmIoYSkpe2lmKGEuYT09
+PTgpe3MuYT0xClAuVGsobnVsbCxudWxsLHMuYix0Lk0uYShuZXcgUC5LRihzLGEpKSl9ZWxzZSBQLkE5
+KGEscykKcmV0dXJufXMuZWMoYSl9LApOazpmdW5jdGlvbihhLGIpe3RoaXMuYT0xClAuVGsobnVsbCxu
+dWxsLHRoaXMuYix0Lk0uYShuZXcgUC5aTCh0aGlzLGEsYikpKX0sCiRpYjg6MX0KUC5kYS5wcm90b3R5
+cGU9ewokMDpmdW5jdGlvbigpe1AuSFoodGhpcy5hLHRoaXMuYil9LAokUzowfQpQLm9RLnByb3RvdHlw
+ZT17CiQwOmZ1bmN0aW9uKCl7UC5IWih0aGlzLmIsdGhpcy5hLmEpfSwKJFM6MH0KUC5wVi5wcm90b3R5
+cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD10aGlzLmEKcC5hPTAKdHJ5e3AuWDIocC4kdGku
+Yy5hKGEpKX1jYXRjaChxKXtzPUguUnUocSkKcj1ILnRzKHEpCnAuWkwocyxyKX19LAokUzoxMH0KUC5V
+Ny5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS5aTChhLHQubC5hKGIpKX0sCiRDOiIk
+MiIsCiRSOjIsCiRTOjI4fQpQLnZyLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRo
+aXMuYix0aGlzLmMpfSwKJFM6MH0KUC5ydC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS5Y
+Mih0aGlzLmIpfSwKJFM6MH0KUC5LRi5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe1AuQTkodGhpcy5i
+LHRoaXMuYSl9LAokUzowfQpQLlpMLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRo
+aXMuYix0aGlzLmMpfSwKJFM6MH0KUC5SVC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIs
+cSxwLG8sbixtPXRoaXMsbD1udWxsCnRyeXtxPW0uYS5hCmw9cS5iLmIuenoodC5mTy5hKHEuZCksdC56
+KX1jYXRjaChwKXtzPUguUnUocCkKcj1ILnRzKHApCmlmKG0uYyl7cT10Lm4uYShtLmIuYS5jKS5hCm89
+cwpvPXE9PW51bGw/bz09bnVsbDpxPT09bwpxPW99ZWxzZSBxPSExCm89bS5hCmlmKHEpby5jPXQubi5h
+KG0uYi5hLmMpCmVsc2Ugby5jPVAuVGwocyxyKQpvLmI9ITAKcmV0dXJufWlmKGwgaW5zdGFuY2VvZiBQ
+LnZzJiZsLmE+PTQpe2lmKGwuYT09PTgpe3E9bS5hCnEuYz10Lm4uYShsLmMpCnEuYj0hMH1yZXR1cm59
+aWYodC5lLmIobCkpe249bS5iLmEKcT1tLmEKcS5jPWwuVzcobmV3IFAualoobiksdC56KQpxLmI9ITF9
+fSwKJFM6MH0KUC5qWi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKJFM6
+Mjl9ClAucnEucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbSxsCnRyeXtx
+PXRoaXMuYQpwPXEuYQpvPXAuJHRpCm49by5jCm09bi5hKHRoaXMuYikKcS5jPXAuYi5iLmJ2KG8uQygi
+Mi8oMSkiKS5hKHAuZCksbSxvLkMoIjIvIiksbil9Y2F0Y2gobCl7cz1ILlJ1KGwpCnI9SC50cyhsKQpx
+PXRoaXMuYQpxLmM9UC5UbChzLHIpCnEuYj0hMH19LAokUzowfQpQLlJXLnByb3RvdHlwZT17CiQwOmZ1
+bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRoaXMKdHJ5e3M9dC5uLmEoay5hLmEuYykKcD1r
+LmIKaWYoSC5vVChwLmEuSFIocykpJiZwLmEuZSE9bnVsbCl7cC5jPXAuYS5LdyhzKQpwLmI9ITF9fWNh
+dGNoKG8pe3I9SC5SdShvKQpxPUgudHMobykKcD10Lm4uYShrLmEuYS5jKQpuPXAuYQptPXIKbD1rLmIK
+aWYobj09bnVsbD9tPT1udWxsOm49PT1tKWwuYz1wCmVsc2UgbC5jPVAuVGwocixxKQpsLmI9ITB9fSwK
+JFM6MH0KUC5PTS5wcm90b3R5cGU9e30KUC5xaC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXt2YXIg
+cyxyLHE9dGhpcyxwPXt9LG89bmV3IFAudnMoJC5YMyx0LmZKKQpwLmE9MApzPUguTGgocSkKcj1zLkMo
+In4oMSk/IikuYShuZXcgUC5CNShwLHEpKQp0LlouYShuZXcgUC51TyhwLG8pKQpXLkpFKHEuYSxxLmIs
+ciwhMSxzLmMpCnJldHVybiBvfX0KUC5CNS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILkxoKHRo
+aXMuYikuYy5hKGEpOysrdGhpcy5hLmF9LAokUzpmdW5jdGlvbigpe3JldHVybiBILkxoKHRoaXMuYiku
+QygifigxKSIpfX0KUC51Ty5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYixyPXMu
+JHRpLHE9ci5DKCIxLyIpLmEodGhpcy5hLmEpLHA9cy5haCgpCnIuYy5hKHEpCnMuYT00CnMuYz1xClAu
+SFoocyxwKX0sCiRTOjB9ClAuTU8ucHJvdG90eXBlPXt9ClAua1QucHJvdG90eXBlPXt9ClAueEkucHJv
+dG90eXBlPXt9ClAubTAucHJvdG90eXBlPXskaVFtOjF9ClAucEsucHJvdG90eXBlPXsKJDA6ZnVuY3Rp
+b24oKXt2YXIgcz1ILmIodGhpcy5hKQpzLnN0YWNrPUouaih0aGlzLmIpCnRocm93IHN9LAokUzowfQpQ
+LkppLnByb3RvdHlwZT17CmJIOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPW51bGwKdC5NLmEoYSkKdHJ5
+e2lmKEMuTlU9PT0kLlgzKXthLiQwKCkKcmV0dXJufVAuVDgocCxwLHRoaXMsYSx0LkgpfWNhdGNoKHEp
+e3M9SC5SdShxKQpyPUgudHMocSkKUC5MMihwLHAsdGhpcyxzLHQubC5hKHIpKX19LApEbDpmdW5jdGlv
+bihhLGIsYyl7dmFyIHMscixxLHA9bnVsbApjLkMoIn4oMCkiKS5hKGEpCmMuYShiKQp0cnl7aWYoQy5O
+VT09PSQuWDMpe2EuJDEoYikKcmV0dXJufVAueXYocCxwLHRoaXMsYSxiLHQuSCxjKX1jYXRjaChxKXtz
+PUguUnUocSkKcj1ILnRzKHEpClAuTDIocCxwLHRoaXMscyx0LmwuYShyKSl9fSwKUlQ6ZnVuY3Rpb24o
+YSxiKXtyZXR1cm4gbmV3IFAuaGoodGhpcyxiLkMoIjAoKSIpLmEoYSksYil9LApHWTpmdW5jdGlvbihh
+KXtyZXR1cm4gbmV3IFAuVnAodGhpcyx0Lk0uYShhKSl9LApQeTpmdW5jdGlvbihhLGIpe3JldHVybiBu
+ZXcgUC5PUih0aGlzLGIuQygifigwKSIpLmEoYSksYil9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51
+bGx9LAp6ejpmdW5jdGlvbihhLGIpe2IuQygiMCgpIikuYShhKQppZigkLlgzPT09Qy5OVSlyZXR1cm4g
+YS4kMCgpCnJldHVybiBQLlQ4KG51bGwsbnVsbCx0aGlzLGEsYil9LApidjpmdW5jdGlvbihhLGIsYyxk
+KXtjLkMoIkA8MD4iKS5LcShkKS5DKCIxKDIpIikuYShhKQpkLmEoYikKaWYoJC5YMz09PUMuTlUpcmV0
+dXJuIGEuJDEoYikKcmV0dXJuIFAueXYobnVsbCxudWxsLHRoaXMsYSxiLGMsZCl9LApycDpmdW5jdGlv
+bihhLGIsYyxkLGUsZil7ZC5DKCJAPDA+IikuS3EoZSkuS3EoZikuQygiMSgyLDMpIikuYShhKQplLmEo
+YikKZi5hKGMpCmlmKCQuWDM9PT1DLk5VKXJldHVybiBhLiQyKGIsYykKcmV0dXJuIFAuUXgobnVsbCxu
+dWxsLHRoaXMsYSxiLGMsZCxlLGYpfSwKTGo6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGIuQygiQDww
+PiIpLktxKGMpLktxKGQpLkMoIjEoMiwzKSIpLmEoYSl9fQpQLmhqLnByb3RvdHlwZT17CiQwOmZ1bmN0
+aW9uKCl7cmV0dXJuIHRoaXMuYS56eih0aGlzLmIsdGhpcy5jKX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJu
+IHRoaXMuYy5DKCIwKCkiKX19ClAuVnAucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtyZXR1cm4gdGhp
+cy5hLmJIKHRoaXMuYil9LAokUzowfQpQLk9SLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBz
+PXRoaXMuYwpyZXR1cm4gdGhpcy5hLkRsKHRoaXMuYixzLmEoYSkscyl9LAokUzpmdW5jdGlvbigpe3Jl
+dHVybiB0aGlzLmMuQygifigwKSIpfX0KUC5iNi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIg
+cz10aGlzLHI9bmV3IFAubG0ocyxzLnIsSC5MaChzKS5DKCJsbTwxPiIpKQpyLmM9cy5lCnJldHVybiBy
+fSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
+cy5hPT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hIT09MH0sCnRnOmZ1bmN0aW9uKGEs
+Yil7dmFyIHMscgppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIil7cz10aGlzLmIK
+aWYocz09bnVsbClyZXR1cm4hMQpyZXR1cm4gdC5tLmEoc1tiXSkhPW51bGx9ZWxzZXtyPXRoaXMuUFIo
+YikKcmV0dXJuIHJ9fSwKUFI6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJu
+ITEKcmV0dXJuIHRoaXMuREYoc1t0aGlzLk4oYSldLGEpPj0wfSwKaTpmdW5jdGlvbihhLGIpe3ZhciBz
+LHIscT10aGlzCkguTGgocSkuYy5hKGIpCmlmKHR5cGVvZiBiPT0ic3RyaW5nIiYmYiE9PSJfX3Byb3Rv
+X18iKXtzPXEuYgpyZXR1cm4gcS5iUShzPT1udWxsP3EuYj1QLlQyKCk6cyxiKX1lbHNlIGlmKHR5cGVv
+ZiBiPT0ibnVtYmVyIiYmKGImMTA3Mzc0MTgyMyk9PT1iKXtyPXEuYwpyZXR1cm4gcS5iUShyPT1udWxs
+P3EuYz1QLlQyKCk6cixiKX1lbHNlIHJldHVybiBxLkI3KGIpfSwKQjc6ZnVuY3Rpb24oYSl7dmFyIHMs
+cixxLHA9dGhpcwpILkxoKHApLmMuYShhKQpzPXAuZAppZihzPT1udWxsKXM9cC5kPVAuVDIoKQpyPXAu
+TihhKQpxPXNbcl0KaWYocT09bnVsbClzW3JdPVtwLnlvKGEpXQplbHNle2lmKHAuREYocSxhKT49MCly
+ZXR1cm4hMQpxLnB1c2gocC55byhhKSl9cmV0dXJuITB9LApSOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhp
+cwppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIilyZXR1cm4gcy5IKHMuYixiKQpl
+bHNlIGlmKHR5cGVvZiBiPT0ibnVtYmVyIiYmKGImMTA3Mzc0MTgyMyk9PT1iKXJldHVybiBzLkgocy5j
+LGIpCmVsc2UgcmV0dXJuIHMucWcoYil9LApxZzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMs
+bj1vLmQKaWYobj09bnVsbClyZXR1cm4hMQpzPW8uTihhKQpyPW5bc10KcT1vLkRGKHIsYSkKaWYocTww
+KXJldHVybiExCnA9ci5zcGxpY2UocSwxKVswXQppZigwPT09ci5sZW5ndGgpZGVsZXRlIG5bc10Kby5H
+KHApCnJldHVybiEwfSwKYlE6ZnVuY3Rpb24oYSxiKXtILkxoKHRoaXMpLmMuYShiKQppZih0Lm0uYShh
+W2JdKSE9bnVsbClyZXR1cm4hMQphW2JdPXRoaXMueW8oYikKcmV0dXJuITB9LApIOmZ1bmN0aW9uKGEs
+Yil7dmFyIHMKaWYoYT09bnVsbClyZXR1cm4hMQpzPXQubS5hKGFbYl0pCmlmKHM9PW51bGwpcmV0dXJu
+ITEKdGhpcy5HKHMpCmRlbGV0ZSBhW2JdCnJldHVybiEwfSwKUzpmdW5jdGlvbigpe3RoaXMucj10aGlz
+LnIrMSYxMDczNzQxODIzfSwKeW86ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLHE9bmV3IFAuYm4oSC5M
+aChyKS5jLmEoYSkpCmlmKHIuZT09bnVsbClyLmU9ci5mPXEKZWxzZXtzPXIuZgpzLnRvU3RyaW5nCnEu
+Yz1zCnIuZj1zLmI9cX0rK3IuYQpyLlMoKQpyZXR1cm4gcX0sCkc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhp
+cyxyPWEuYyxxPWEuYgppZihyPT1udWxsKXMuZT1xCmVsc2Ugci5iPXEKaWYocT09bnVsbClzLmY9cgpl
+bHNlIHEuYz1yOy0tcy5hCnMuUygpfSwKTjpmdW5jdGlvbihhKXtyZXR1cm4gSi5oZihhKSYxMDczNzQx
+ODIzfSwKREY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGE9PW51bGwpcmV0dXJuLTEKcz1hLmxlbmd0
+aApmb3Iocj0wO3I8czsrK3IpaWYoSi5STShhW3JdLmEsYikpcmV0dXJuIHIKcmV0dXJuLTF9fQpQLmJu
+LnByb3RvdHlwZT17fQpQLmxtLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0s
+CkY6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5jLHE9cy5hCmlmKHMuYiE9PXEucil0aHJvdyBILmIo
+UC5hNChxKSkKZWxzZSBpZihyPT1udWxsKXtzLnNqKG51bGwpCnJldHVybiExfWVsc2V7cy5zaihzLiR0
+aS5DKCIxPyIpLmEoci5hKSkKcy5jPXIuYgpyZXR1cm4hMH19LApzajpmdW5jdGlvbihhKXt0aGlzLmQ9
+dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpQLm1XLnByb3RvdHlwZT17fQpQLnV5LnByb3Rv
+dHlwZT17JGliUToxLCRpY1g6MSwkaXpNOjF9ClAubEQucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7
+cmV0dXJuIG5ldyBILmE3KGEsdGhpcy5nQShhKSxILnooYSkuQygiYTc8bEQuRT4iKSl9LApFOmZ1bmN0
+aW9uKGEsYil7cmV0dXJuIHRoaXMucShhLGIpfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC56KGEp
+LkMoIn4obEQuRSkiKS5hKGIpCnM9dGhpcy5nQShhKQpmb3Iocj0wO3I8czsrK3Ipe2IuJDEodGhpcy5x
+KGEscikpCmlmKHMhPT10aGlzLmdBKGEpKXRocm93IEguYihQLmE0KGEpKX19LApnbDA6ZnVuY3Rpb24o
+YSl7cmV0dXJuIHRoaXMuZ0EoYSk9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdsMChh
+KX0sCkUyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILnooYSkKcmV0dXJuIG5ldyBILmxKKGEscy5LcShj
+KS5DKCIxKGxELkUpIikuYShiKSxzLkMoIkA8bEQuRT4iKS5LcShjKS5DKCJsSjwxLDI+IikpfSwKZVI6
+ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5xQyhhLGIsbnVsbCxILnooYSkuQygibEQuRSIpKX0sCmRyOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILmpWKGEsSC56KGEpLkMoIkA8bEQuRT4iKS5LcShiKS5DKCJq
+VjwxLDI+IikpfSwKZHU6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMKSC56KGEpLkMoImxELkU/IikuYShk
+KQpQLmpCKGIsYyx0aGlzLmdBKGEpKQpmb3Iocz1iO3M8YzsrK3MpdGhpcy5ZNShhLHMsZCl9LAp3OmZ1
+bmN0aW9uKGEpe3JldHVybiBQLldFKGEsIlsiLCJdIil9fQpQLmlsLnByb3RvdHlwZT17fQpQLnJhLnBy
+b3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmEKaWYoIXIuYSl0aGlzLmIuYSs9
+IiwgIgpyLmE9ITEKcj10aGlzLmIKcz1yLmErPUguRWooYSkKci5hPXMrIjogIgpyLmErPUguRWooYil9
+LAokUzoxMX0KUC5Zay5wcm90b3R5cGU9ewpLOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILkxoKHRoaXMp
+LkMoIn4oWWsuSyxZay5WKSIpLmEoYikKZm9yKHM9Si5JVCh0aGlzLmd2YygpKTtzLkYoKTspe3I9cy5n
+bCgpCmIuJDIocix0aGlzLnEoMCxyKSl9fSwKZ1B1OmZ1bmN0aW9uKGEpe3JldHVybiBKLk0xKHRoaXMu
+Z3ZjKCksbmV3IFAueVEodGhpcyksSC5MaCh0aGlzKS5DKCJOMzxZay5LLFlrLlY+IikpfSwKeDQ6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIEouemwodGhpcy5ndmMoKSxhKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiBK
+LkhtKHRoaXMuZ3ZjKCkpfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiBKLnVVKHRoaXMuZ3ZjKCkpfSwK
+dzpmdW5jdGlvbihhKXtyZXR1cm4gUC5uTyh0aGlzKX0sCiRpWjA6MX0KUC55US5wcm90b3R5cGU9ewok
+MTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEscj1ILkxoKHMpCnIuQygiWWsuSyIpLmEoYSkKcmV0dXJu
+IG5ldyBQLk4zKGEscy5xKDAsYSksci5DKCJAPFlrLks+IikuS3Eoci5DKCJZay5WIikpLkMoIk4zPDEs
+Mj4iKSl9LAokUzpmdW5jdGlvbigpe3JldHVybiBILkxoKHRoaXMuYSkuQygiTjM8WWsuSyxZay5WPihZ
+ay5LKSIpfX0KUC5LUC5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC5MaCh0aGlz
+KQpzLmMuYShiKQpzLlFbMV0uYShjKQp0aHJvdyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSB1bm1vZGlm
+aWFibGUgbWFwIikpfX0KUC5Qbi5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMu
+YS5xKDAsYil9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC5MaCh0aGlzKQp0aGlzLmEuWTUoMCxz
+LmMuYShiKSxzLlFbMV0uYShjKSl9LAp4NDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLng0KGEpfSwK
+SzpmdW5jdGlvbihhLGIpe3RoaXMuYS5LKDAsSC5MaCh0aGlzKS5DKCJ+KDEsMikiKS5hKGIpKX0sCmds
+MDpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ2wwKHMpfSwKZ0E6ZnVuY3Rpb24oYSl7
+dmFyIHM9dGhpcy5hCnJldHVybiBzLmdBKHMpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gSi5qKHRoaXMu
+YSl9LApnUHU6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmdQdShzKX0sCiRpWjA6MX0K
+UC5Hai5wcm90b3R5cGU9e30KUC5sZi5wcm90b3R5cGU9ewpnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
+aXMuZ0EodGhpcyk9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpIT09MH0s
+CkZWOmZ1bmN0aW9uKGEsYil7dmFyIHMKZm9yKHM9Si5JVChILkxoKHRoaXMpLkMoImNYPGxmLkU+Iiku
+YShiKSk7cy5GKCk7KXRoaXMuaSgwLHMuZ2woKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLldFKHRo
+aXMsInsiLCJ9Iil9LAprOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmdtKHRoaXMpCmlmKCFyLkYo
+KSlyZXR1cm4iIgppZihiPT09IiIpe3M9IiIKZG8gcys9SC5FaihyLmQpCndoaWxlKHIuRigpKX1lbHNl
+e3M9SC5FaihyLmQpCmZvcig7ci5GKCk7KXM9cytiK0guRWooci5kKX1yZXR1cm4gcy5jaGFyQ29kZUF0
+KDApPT0wP3M6c30sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguYksodGhpcyxiLEguTGgodGhpcyku
+QygibGYuRSIpKX0sCkU6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscD0iaW5kZXgiCkguY2IoYixwLHQu
+UykKUC5rMShiLHApCmZvcihzPXRoaXMuZ20odGhpcykscj0wO3MuRigpOyl7cT1zLmQKaWYoYj09PXIp
+cmV0dXJuIHE7KytyfXRocm93IEguYihQLkNmKGIsdGhpcyxwLG51bGwscikpfX0KUC5Wai5wcm90b3R5
+cGU9eyRpYlE6MSwkaWNYOjEsJGl4dToxfQpQLlh2LnByb3RvdHlwZT17JGliUToxLCRpY1g6MSwkaXh1
+OjF9ClAublkucHJvdG90eXBlPXt9ClAuV1kucHJvdG90eXBlPXt9ClAuUlUucHJvdG90eXBlPXt9ClAu
+cFIucHJvdG90eXBlPXt9ClAudXcucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9dGhp
+cy5iCmlmKHI9PW51bGwpcmV0dXJuIHRoaXMuYy5xKDAsYikKZWxzZSBpZih0eXBlb2YgYiE9InN0cmlu
+ZyIpcmV0dXJuIG51bGwKZWxzZXtzPXJbYl0KcmV0dXJuIHR5cGVvZiBzPT0idW5kZWZpbmVkIj90aGlz
+LmZiKGIpOnN9fSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYj09bnVsbD90aGlzLmMuYTp0aGlz
+LkNmKCkubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmdBKHRoaXMpPT09MH0sCmd2
+YzpmdW5jdGlvbigpe2lmKHRoaXMuYj09bnVsbCl7dmFyIHM9dGhpcy5jCnJldHVybiBuZXcgSC5pNShz
+LEguTGgocykuQygiaTU8MT4iKSl9cmV0dXJuIG5ldyBQLmk4KHRoaXMpfSwKWTU6ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBzLHIscT10aGlzCmlmKHEuYj09bnVsbClxLmMuWTUoMCxiLGMpCmVsc2UgaWYocS54NChi
+KSl7cz1xLmIKc1tiXT1jCnI9cS5hCmlmKHI9PW51bGw/cyE9bnVsbDpyIT09cylyW2JdPW51bGx9ZWxz
+ZSBxLlhLKCkuWTUoMCxiLGMpfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodGhpcy5iPT1udWxsKXJldHVybiB0
+aGlzLmMueDQoYSkKcmV0dXJuIE9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlz
+LmEsYSl9LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz10aGlzCnQuY0EuYShiKQppZihvLmI9
+PW51bGwpcmV0dXJuIG8uYy5LKDAsYikKcz1vLkNmKCkKZm9yKHI9MDtyPHMubGVuZ3RoOysrcil7cT1z
+W3JdCnA9by5iW3FdCmlmKHR5cGVvZiBwPT0idW5kZWZpbmVkIil7cD1QLlFlKG8uYVtxXSkKby5iW3Fd
+PXB9Yi4kMihxLHApCmlmKHMhPT1vLmMpdGhyb3cgSC5iKFAuYTQobykpfX0sCkNmOmZ1bmN0aW9uKCl7
+dmFyIHM9dC5iTS5hKHRoaXMuYykKaWYocz09bnVsbClzPXRoaXMuYz1ILlZNKE9iamVjdC5rZXlzKHRo
+aXMuYSksdC5zKQpyZXR1cm4gc30sClhLOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuPXRoaXMKaWYo
+bi5iPT1udWxsKXJldHVybiBuLmMKcz1QLkZsKHQuTix0LnopCnI9bi5DZigpCmZvcihxPTA7cD1yLmxl
+bmd0aCxxPHA7KytxKXtvPXJbcV0Kcy5ZNSgwLG8sbi5xKDAsbykpfWlmKHA9PT0wKUMuTm0uaShyLCIi
+KQplbHNlIEMuTm0uc0EociwwKQpuLmE9bi5iPW51bGwKcmV0dXJuIG4uYz1zfSwKZmI6ZnVuY3Rpb24o
+YSl7dmFyIHMKaWYoIU9iamVjdC5wcm90b3R5cGUuaGFzT3duUHJvcGVydHkuY2FsbCh0aGlzLmEsYSkp
+cmV0dXJuIG51bGwKcz1QLlFlKHRoaXMuYVthXSkKcmV0dXJuIHRoaXMuYlthXT1zfX0KUC5pOC5wcm90
+b3R5cGU9ewpnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ0Eocyl9LApFOmZ1bmN0
+aW9uKGEsYil7dmFyIHM9dGhpcy5hCmlmKHMuYj09bnVsbClzPXMuZ3ZjKCkuRSgwLGIpCmVsc2V7cz1z
+LkNmKCkKaWYoYjwwfHxiPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGIpCnM9c1tiXX1yZXR1cm4gc30s
+CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQppZihzLmI9PW51bGwpe3M9cy5ndmMoKQpzPXMuZ20o
+cyl9ZWxzZXtzPXMuQ2YoKQpzPW5ldyBKLm0xKHMscy5sZW5ndGgsSC50NihzKS5DKCJtMTwxPiIpKX1y
+ZXR1cm4gc30sCnRnOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS54NChiKX19ClAueHIucHJvdG90
+eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyCnRyeXtzPW5ldyBUZXh0RGVjb2RlcigidXRmLTgiLHtm
+YXRhbDp0cnVlfSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1yZXR1cm4gbnVsbH0sCiRTOjEyfQpQ
+Lk56LnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscgp0cnl7cz1uZXcgVGV4dERlY29kZXIo
+InV0Zi04Iix7ZmF0YWw6ZmFsc2V9KQpyZXR1cm4gc31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxs
+fSwKJFM6MTJ9ClAuQ1YucHJvdG90eXBlPXsKeXI6ZnVuY3Rpb24oYTAsYTEsYTIpe3ZhciBzLHIscSxw
+LG8sbixtLGwsayxqLGksaCxnLGYsZSxkLGMsYixhPSJJbnZhbGlkIGJhc2U2NCBlbmNvZGluZyBsZW5n
+dGggIgphMj1QLmpCKGExLGEyLGEwLmxlbmd0aCkKcz0kLlY3KCkKZm9yKHI9YTEscT1yLHA9bnVsbCxv
+PS0xLG49LTEsbT0wO3I8YTI7cj1sKXtsPXIrMQprPUMueEIuVyhhMCxyKQppZihrPT09Mzcpe2o9bCsy
+CmlmKGo8PWEyKXtpPUgub28oQy54Qi5XKGEwLGwpKQpoPUgub28oQy54Qi5XKGEwLGwrMSkpCmc9aSox
+NitoLShoJjI1NikKaWYoZz09PTM3KWc9LTEKbD1qfWVsc2UgZz0tMX1lbHNlIGc9awppZigwPD1nJiZn
+PD0xMjcpe2lmKGc8MHx8Zz49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxnKQpmPXNbZ10KaWYoZj49MCl7
+Zz1DLnhCLk8oIkFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4
+eXowMTIzNDU2Nzg5Ky8iLGYpCmlmKGc9PT1rKWNvbnRpbnVlCms9Z31lbHNle2lmKGY9PT0tMSl7aWYo
+bzwwKXtlPXA9PW51bGw/bnVsbDpwLmEubGVuZ3RoCmlmKGU9PW51bGwpZT0wCm89ZSsoci1xKQpuPXJ9
+KyttCmlmKGs9PT02MSljb250aW51ZX1rPWd9aWYoZiE9PS0yKXtpZihwPT1udWxsKXtwPW5ldyBQLlJu
+KCIiKQplPXB9ZWxzZSBlPXAKZS5hKz1DLnhCLk5qKGEwLHEscikKZS5hKz1ILkx3KGspCnE9bApjb250
+aW51ZX19dGhyb3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IGRhdGEiLGEwLHIpKX1pZihwIT1udWxs
+KXtlPXAuYSs9Qy54Qi5OaihhMCxxLGEyKQpkPWUubGVuZ3RoCmlmKG8+PTApUC54TShhMCxuLGEyLG8s
+bSxkKQplbHNle2M9Qy5qbi56WShkLTEsNCkrMQppZihjPT09MSl0aHJvdyBILmIoUC5ycihhLGEwLGEy
+KSkKZm9yKDtjPDQ7KXtlKz0iPSIKcC5hPWU7KytjfX1lPXAuYQpyZXR1cm4gQy54Qi5pNyhhMCxhMSxh
+MixlLmNoYXJDb2RlQXQoMCk9PTA/ZTplKX1iPWEyLWExCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxi
+KQplbHNle2M9Qy5qbi56WShiLDQpCmlmKGM9PT0xKXRocm93IEguYihQLnJyKGEsYTAsYTIpKQppZihj
+PjEpYTA9Qy54Qi5pNyhhMCxhMixhMixjPT09Mj8iPT0iOiI9Iil9cmV0dXJuIGEwfX0KUC5VOC5wcm90
+b3R5cGU9e30KUC5Vay5wcm90b3R5cGU9e30KUC53SS5wcm90b3R5cGU9e30KUC5aaS5wcm90b3R5cGU9
+e30KUC5VZC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPVAucCh0aGlzLmEpCnJldHVybih0
+aGlzLmIhPW51bGw/IkNvbnZlcnRpbmcgb2JqZWN0IHRvIGFuIGVuY29kYWJsZSBvYmplY3QgZmFpbGVk
+OiI6IkNvbnZlcnRpbmcgb2JqZWN0IGRpZCBub3QgcmV0dXJuIGFuIGVuY29kYWJsZSBvYmplY3Q6Iikr
+IiAiK3N9fQpQLks4LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkN5Y2xpYyBlcnJvciBp
+biBKU09OIHN0cmluZ2lmeSJ9fQpQLmJ5LnByb3RvdHlwZT17CnBXOmZ1bmN0aW9uKGEsYixjKXt2YXIg
+cwp0LmZWLmEoYykKcz1QLkJTKGIsdGhpcy5nSGUoKS5hKQpyZXR1cm4gc30sCk9COmZ1bmN0aW9uKGEs
+Yil7dmFyIHMKdC5kQS5hKGIpCnM9UC51WChhLHRoaXMuZ1pFKCkuYixudWxsKQpyZXR1cm4gc30sCmda
+RTpmdW5jdGlvbigpe3JldHVybiBDLm5YfSwKZ0hlOmZ1bmN0aW9uKCl7cmV0dXJuIEMuQTN9fQpQLm9q
+LnByb3RvdHlwZT17fQpQLk14LnByb3RvdHlwZT17fQpQLlNoLnByb3RvdHlwZT17CnZwOmZ1bmN0aW9u
+KGEpe3ZhciBzLHIscSxwLG8sbixtLGw9YS5sZW5ndGgKZm9yKHM9Si5yWShhKSxyPXRoaXMuYyxxPTAs
+cD0wO3A8bDsrK3Ape289cy5XKGEscCkKaWYobz45Mil7aWYobz49NTUyOTYpe249byY2NDUxMgppZihu
+PT09NTUyOTYpe209cCsxCm09IShtPGwmJihDLnhCLlcoYSxtKSY2NDUxMik9PT01NjMyMCl9ZWxzZSBt
+PSExCmlmKCFtKWlmKG49PT01NjMyMCl7bj1wLTEKbj0hKG4+PTAmJihDLnhCLk8oYSxuKSY2NDUxMik9
+PT01NTI5Nil9ZWxzZSBuPSExCmVsc2Ugbj0hMAppZihuKXtpZihwPnEpci5hKz1DLnhCLk5qKGEscSxw
+KQpxPXArMQpyLmErPUguTHcoOTIpCnIuYSs9SC5MdygxMTcpCnIuYSs9SC5MdygxMDApCm49bz4+Pjgm
+MTUKci5hKz1ILkx3KG48MTA/NDgrbjo4NytuKQpuPW8+Pj40JjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246
+ODcrbikKbj1vJjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbil9fWNvbnRpbnVlfWlmKG88MzIpe2lm
+KHA+cSlyLmErPUMueEIuTmooYSxxLHApCnE9cCsxCnIuYSs9SC5Mdyg5MikKc3dpdGNoKG8pe2Nhc2Ug
+ODpyLmErPUguTHcoOTgpCmJyZWFrCmNhc2UgOTpyLmErPUguTHcoMTE2KQpicmVhawpjYXNlIDEwOnIu
+YSs9SC5MdygxMTApCmJyZWFrCmNhc2UgMTI6ci5hKz1ILkx3KDEwMikKYnJlYWsKY2FzZSAxMzpyLmEr
+PUguTHcoMTE0KQpicmVhawpkZWZhdWx0OnIuYSs9SC5MdygxMTcpCnIuYSs9SC5Mdyg0OCkKci5hKz1I
+Lkx3KDQ4KQpuPW8+Pj40JjE1CnIuYSs9SC5MdyhuPDEwPzQ4K246ODcrbikKbj1vJjE1CnIuYSs9SC5M
+dyhuPDEwPzQ4K246ODcrbikKYnJlYWt9fWVsc2UgaWYobz09PTM0fHxvPT09OTIpe2lmKHA+cSlyLmEr
+PUMueEIuTmooYSxxLHApCnE9cCsxCnIuYSs9SC5Mdyg5MikKci5hKz1ILkx3KG8pfX1pZihxPT09MCly
+LmErPUguRWooYSkKZWxzZSBpZihxPGwpci5hKz1zLk5qKGEscSxsKX0sCkpuOmZ1bmN0aW9uKGEpe3Zh
+ciBzLHIscSxwCmZvcihzPXRoaXMuYSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPXNbcV0KaWYoYT09
+bnVsbD9wPT1udWxsOmE9PT1wKXRocm93IEguYihuZXcgUC5LOChhLG51bGwpKX1DLk5tLmkocyxhKX0s
+CmlVOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG89dGhpcwppZihvLnRNKGEpKXJldHVybgpvLkpuKGEp
+CnRyeXtzPW8uYi4kMShhKQppZighby50TShzKSl7cT1QLkd5KGEsbnVsbCxvLmdWSygpKQp0aHJvdyBI
+LmIocSl9cT1vLmEKaWYoMD49cS5sZW5ndGgpcmV0dXJuIEguT0gocSwtMSkKcS5wb3AoKX1jYXRjaChw
+KXtyPUguUnUocCkKcT1QLkd5KGEscixvLmdWSygpKQp0aHJvdyBILmIocSl9fSwKdE06ZnVuY3Rpb24o
+YSl7dmFyIHMscixxPXRoaXMKaWYodHlwZW9mIGE9PSJudW1iZXIiKXtpZighaXNGaW5pdGUoYSkpcmV0
+dXJuITEKcS5jLmErPUMuQ0QudyhhKQpyZXR1cm4hMH1lbHNlIGlmKGE9PT0hMCl7cS5jLmErPSJ0cnVl
+IgpyZXR1cm4hMH1lbHNlIGlmKGE9PT0hMSl7cS5jLmErPSJmYWxzZSIKcmV0dXJuITB9ZWxzZSBpZihh
+PT1udWxsKXtxLmMuYSs9Im51bGwiCnJldHVybiEwfWVsc2UgaWYodHlwZW9mIGE9PSJzdHJpbmciKXtz
+PXEuYwpzLmErPSciJwpxLnZwKGEpCnMuYSs9JyInCnJldHVybiEwfWVsc2UgaWYodC5qLmIoYSkpe3Eu
+Sm4oYSkKcS5sSyhhKQpzPXEuYQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgp
+CnJldHVybiEwfWVsc2UgaWYodC5mLmIoYSkpe3EuSm4oYSkKcj1xLmp3KGEpCnM9cS5hCmlmKDA+PXMu
+bGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcmV0dXJuIHJ9ZWxzZSByZXR1cm4hMX0sCmxL
+OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLmMKcS5hKz0iWyIKcz1KLlU2KGEpCmlmKHMuZ29yKGEp
+KXt0aGlzLmlVKHMucShhLDApKQpmb3Iocj0xO3I8cy5nQShhKTsrK3Ipe3EuYSs9IiwiCnRoaXMuaVUo
+cy5xKGEscikpfX1xLmErPSJdIn0sCmp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMs
+bD17fQppZihhLmdsMChhKSl7bS5jLmErPSJ7fSIKcmV0dXJuITB9cz1hLmdBKGEpKjIKcj1QLk84KHMs
+bnVsbCwhMSx0LlcpCnE9bC5hPTAKbC5iPSEwCmEuSygwLG5ldyBQLnRpKGwscikpCmlmKCFsLmIpcmV0
+dXJuITEKcD1tLmMKcC5hKz0ieyIKZm9yKG89JyInO3E8cztxKz0yLG89JywiJyl7cC5hKz1vCm0udnAo
+SC5oKHJbcV0pKQpwLmErPSciOicKbj1xKzEKaWYobj49cylyZXR1cm4gSC5PSChyLG4pCm0uaVUocltu
+XSl9cC5hKz0ifSIKcmV0dXJuITB9fQpQLnRpLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFy
+IHMscgppZih0eXBlb2YgYSE9InN0cmluZyIpdGhpcy5hLmI9ITEKcz10aGlzLmIKcj10aGlzLmEKQy5O
+bS5ZNShzLHIuYSsrLGEpCkMuTm0uWTUocyxyLmErKyxiKX0sCiRTOjExfQpQLnR1LnByb3RvdHlwZT17
+CmdWSzpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpz
+fX0KUC51NS5wcm90b3R5cGU9ewpnWkU6ZnVuY3Rpb24oKXtyZXR1cm4gQy5Ra319ClAuRTMucHJvdG90
+eXBlPXsKV0o6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9UC5qQigwLG51bGwsYS5sZW5ndGgpLG89cC0w
+CmlmKG89PT0wKXJldHVybiBuZXcgVWludDhBcnJheSgwKQpzPW8qMwpyPW5ldyBVaW50OEFycmF5KHMp
+CnE9bmV3IFAuUncocikKaWYocS5HeChhLDAscCkhPT1wKXtKLmE2KGEscC0xKQpxLlJPKCl9cmV0dXJu
+IG5ldyBVaW50OEFycmF5KHIuc3ViYXJyYXkoMCxILnJNKDAscS5iLHMpKSl9fQpQLlJ3LnByb3RvdHlw
+ZT17ClJPOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYyxxPXMuYixwPXMuYj1xKzEsbz1yLmxlbmd0
+aAppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT0yMzkKcT1zLmI9cCsxCmlmKHA+PW8pcmV0dXJu
+IEguT0gocixwKQpyW3BdPTE5MQpzLmI9cSsxCmlmKHE+PW8pcmV0dXJuIEguT0gocixxKQpyW3FdPTE4
+OX0sCk82OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuPXRoaXMKaWYoKGImNjQ1MTIpPT09NTYz
+MjApe3M9NjU1MzYrKChhJjEwMjMpPDwxMCl8YiYxMDIzCnI9bi5jCnE9bi5iCnA9bi5iPXErMQpvPXIu
+bGVuZ3RoCmlmKHE+PW8pcmV0dXJuIEguT0gocixxKQpyW3FdPXM+Pj4xOHwyNDAKcT1uLmI9cCsxCmlm
+KHA+PW8pcmV0dXJuIEguT0gocixwKQpyW3BdPXM+Pj4xMiY2M3wxMjgKcD1uLmI9cSsxCmlmKHE+PW8p
+cmV0dXJuIEguT0gocixxKQpyW3FdPXM+Pj42JjYzfDEyOApuLmI9cCsxCmlmKHA+PW8pcmV0dXJuIEgu
+T0gocixwKQpyW3BdPXMmNjN8MTI4CnJldHVybiEwfWVsc2V7bi5STygpCnJldHVybiExfX0sCkd4OmZ1
+bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbSxsPXRoaXMKaWYoYiE9PWMmJihDLnhCLk8oYSxj
+LTEpJjY0NTEyKT09PTU1Mjk2KS0tYwpmb3Iocz1sLmMscj1zLmxlbmd0aCxxPWI7cTxjOysrcSl7cD1D
+LnhCLlcoYSxxKQppZihwPD0xMjcpe289bC5iCmlmKG8+PXIpYnJlYWsKbC5iPW8rMQpzW29dPXB9ZWxz
+ZXtvPXAmNjQ1MTIKaWYobz09PTU1Mjk2KXtpZihsLmIrND5yKWJyZWFrCm49cSsxCmlmKGwuTzYocCxD
+LnhCLlcoYSxuKSkpcT1ufWVsc2UgaWYobz09PTU2MzIwKXtpZihsLmIrMz5yKWJyZWFrCmwuUk8oKX1l
+bHNlIGlmKHA8PTIwNDcpe289bC5iCm09bysxCmlmKG0+PXIpYnJlYWsKbC5iPW0KaWYobz49cilyZXR1
+cm4gSC5PSChzLG8pCnNbb109cD4+PjZ8MTkyCmwuYj1tKzEKc1ttXT1wJjYzfDEyOH1lbHNle289bC5i
+CmlmKG8rMj49cilicmVhawptPWwuYj1vKzEKaWYobz49cilyZXR1cm4gSC5PSChzLG8pCnNbb109cD4+
+PjEyfDIyNApvPWwuYj1tKzEKaWYobT49cilyZXR1cm4gSC5PSChzLG0pCnNbbV09cD4+PjYmNjN8MTI4
+CmwuYj1vKzEKaWYobz49cilyZXR1cm4gSC5PSChzLG8pCnNbb109cCY2M3wxMjh9fX1yZXR1cm4gcX19
+ClAuR1kucHJvdG90eXBlPXsKV0o6ZnVuY3Rpb24oYSl7dmFyIHMscgp0LkwuYShhKQpzPXRoaXMuYQpy
+PVAua3kocyxhLDAsbnVsbCkKaWYociE9bnVsbClyZXR1cm4gcgpyZXR1cm4gbmV3IFAuYnoocykuTmUo
+YSwwLG51bGwsITApfX0KUC5iei5wcm90b3R5cGU9ewpOZTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxy
+LHEscCxvLG49dGhpcwp0LkwuYShhKQpzPVAuakIoYixjLEouSG0oYSkpCmlmKGI9PT1zKXJldHVybiIi
+CnI9UC5qeShhLGIscykKcT1uLmhPKHIsMCxzLWIsITApCnA9bi5iCmlmKChwJjEpIT09MCl7bz1QLmo0
+KHApCm4uYj0wCnRocm93IEguYihQLnJyKG8sYSxiK24uYykpfXJldHVybiBxfSwKaE86ZnVuY3Rpb24o
+YSxiLGMsZCl7dmFyIHMscixxPXRoaXMKaWYoYy1iPjEwMDApe3M9Qy5qbi5CVShiK2MsMikKcj1xLmhP
+KGEsYixzLCExKQppZigocS5iJjEpIT09MClyZXR1cm4gcgpyZXR1cm4gcitxLmhPKGEscyxjLGQpfXJl
+dHVybiBxLkVoKGEsYixjLGQpfSwKRWg6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuLG0s
+bCxrPXRoaXMsaj02NTUzMyxpPWsuYixoPWsuYyxnPW5ldyBQLlJuKCIiKSxmPWIrMSxlPWEubGVuZ3Ro
+CmlmKGI8MHx8Yj49ZSlyZXR1cm4gSC5PSChhLGIpCnM9YVtiXQokbGFiZWwwJDA6Zm9yKHI9ay5hOyEw
+Oyl7Zm9yKDshMDtmPW8pe3E9Qy54Qi5XKCJBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
+QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
+QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUZGRkZGRkZGRkZGRkZGRkZHR0dHR0dHR0dH
+R0dHR0dHSEhISEhISEhISEhISEhISEhISEhISEhISEhISUhISEpFRUJCQkJCQkJCQkJCQkJCQkJCQkJC
+QkJCQkJCQkJCQktDQ0NDQ0NDQ0NDQ0NEQ0xPTk5OTUVFRUVFRUVFRUVFIixzKSYzMQpoPWk8PTMyP3Mm
+NjE2OTQ+Pj5xOihzJjYzfGg8PDYpPj4+MAppPUMueEIuVygiIFx4MDAwOlhFQ0NDQ0NOOmxEYiBceDAw
+MDpYRUNDQ0NDTnZsRGIgXHgwMDA6WEVDQ0NDQ046bERiIEFBQUFBXHgwMFx4MDBceDAwXHgwMFx4MDBB
+QUFBQTAwMDAwQUFBQUE6Ojo6OkFBQUFBR0cwMDBBQUFBQTAwS0tLQUFBQUFHOjo6OkFBQUFBOklJSUlB
+QUFBQTAwMFx4ODAwQUFBQUFceDAwXHgwMFx4MDBceDAwIEFBQUFBIixpK3EpCmlmKGk9PT0wKXtnLmEr
+PUguTHcoaCkKaWYoZj09PWMpYnJlYWsgJGxhYmVsMCQwCmJyZWFrfWVsc2UgaWYoKGkmMSkhPT0wKXtp
+ZihyKXN3aXRjaChpKXtjYXNlIDY5OmNhc2UgNjc6Zy5hKz1ILkx3KGopCmJyZWFrCmNhc2UgNjU6Zy5h
+Kz1ILkx3KGopOy0tZgpicmVhawpkZWZhdWx0OnA9Zy5hKz1ILkx3KGopCmcuYT1wK0guTHcoaikKYnJl
+YWt9ZWxzZXtrLmI9aQprLmM9Zi0xCnJldHVybiIifWk9MH1pZihmPT09YylicmVhayAkbGFiZWwwJDAK
+bz1mKzEKaWYoZjwwfHxmPj1lKXJldHVybiBILk9IKGEsZikKcz1hW2ZdfW89ZisxCmlmKGY8MHx8Zj49
+ZSlyZXR1cm4gSC5PSChhLGYpCnM9YVtmXQppZihzPDEyOCl7d2hpbGUoITApe2lmKCEobzxjKSl7bj1j
+CmJyZWFrfW09bysxCmlmKG88MHx8bz49ZSlyZXR1cm4gSC5PSChhLG8pCnM9YVtvXQppZihzPj0xMjgp
+e249bS0xCm89bQpicmVha31vPW19aWYobi1mPDIwKWZvcihsPWY7bDxuOysrbCl7aWYobD49ZSlyZXR1
+cm4gSC5PSChhLGwpCmcuYSs9SC5MdyhhW2xdKX1lbHNlIGcuYSs9UC5ITShhLGYsbikKaWYobj09PWMp
+YnJlYWsgJGxhYmVsMCQwCmY9b31lbHNlIGY9b31pZihkJiZpPjMyKWlmKHIpZy5hKz1ILkx3KGopCmVs
+c2V7ay5iPTc3CmsuYz1jCnJldHVybiIifWsuYj1pCmsuYz1oCmU9Zy5hCnJldHVybiBlLmNoYXJDb2Rl
+QXQoMCk9PTA/ZTplfX0KUC5XRi5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQp0
+LmZvLmEoYSkKcz10aGlzLmIKcj10aGlzLmEKcy5hKz1yLmEKcT1zLmErPUguRWooYS5hKQpzLmE9cSsi
+OiAiCnMuYSs9UC5wKGIpCnIuYT0iLCAifSwKJFM6NDB9ClAuaVAucHJvdG90eXBlPXsKRE46ZnVuY3Rp
+b24oYSxiKXtpZihiPT1udWxsKXJldHVybiExCnJldHVybiBiIGluc3RhbmNlb2YgUC5pUCYmdGhpcy5h
+PT09Yi5hJiYhMH0sCmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuKHNeQy5qbi53Ryhz
+LDMwKSkmMTA3Mzc0MTgyM30sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPVAuR3EoSC50SihzKSks
+cT1QLmgwKEguTlMocykpLHA9UC5oMChILmpBKHMpKSxvPVAuaDAoSC5JWChzKSksbj1QLmgwKEguY2go
+cykpLG09UC5oMChILkpkKHMpKSxsPVAuVngoSC5vMShzKSksaz1yKyItIitxKyItIitwKyIgIitvKyI6
+IituKyI6IittKyIuIitsCnJldHVybiBrfX0KUC5YUy5wcm90b3R5cGU9ewpnSUk6ZnVuY3Rpb24oKXty
+ZXR1cm4gSC50cyh0aGlzLiR0aHJvd25Kc0Vycm9yKX19ClAuQzYucHJvdG90eXBlPXsKdzpmdW5jdGlv
+bihhKXt2YXIgcz10aGlzLmEKaWYocyE9bnVsbClyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDogIitQLnAo
+cykKcmV0dXJuIkFzc2VydGlvbiBmYWlsZWQifX0KUC5Fei5wcm90b3R5cGU9e30KUC5GLnByb3RvdHlw
+ZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlRocm93IG9mIG51bGwuIn19ClAudS5wcm90b3R5cGU9ewpn
+WjpmdW5jdGlvbigpe3JldHVybiJJbnZhbGlkIGFyZ3VtZW50IisoIXRoaXMuYT8iKHMpIjoiIil9LApn
+dTpmdW5jdGlvbigpe3JldHVybiIifSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxwPXEuYyxv
+PXA9PW51bGw/IiI6IiAoIitwKyIpIixuPXEuZCxtPW49PW51bGw/IiI6IjogIitILkVqKG4pLGw9cS5n
+WigpK28rbQppZighcS5hKXJldHVybiBsCnM9cS5ndSgpCnI9UC5wKHEuYikKcmV0dXJuIGwrcysiOiAi
+K3J9fQpQLmJKLnByb3RvdHlwZT17CmdaOmZ1bmN0aW9uKCl7cmV0dXJuIlJhbmdlRXJyb3IifSwKZ3U6
+ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMuZSxxPXRoaXMuZgppZihyPT1udWxsKXM9cSE9bnVsbD8iOiBO
+b3QgbGVzcyB0aGFuIG9yIGVxdWFsIHRvICIrSC5FaihxKToiIgplbHNlIGlmKHE9PW51bGwpcz0iOiBO
+b3QgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvICIrSC5FaihyKQplbHNlIGlmKHE+cilzPSI6IE5vdCBp
+biBpbmNsdXNpdmUgcmFuZ2UgIitILkVqKHIpKyIuLiIrSC5FaihxKQplbHNlIHM9cTxyPyI6IFZhbGlk
+IHZhbHVlIHJhbmdlIGlzIGVtcHR5IjoiOiBPbmx5IHZhbGlkIHZhbHVlIGlzICIrSC5FaihyKQpyZXR1
+cm4gc319ClAuZVkucHJvdG90eXBlPXsKZ1o6ZnVuY3Rpb24oKXtyZXR1cm4iUmFuZ2VFcnJvciJ9LApn
+dTpmdW5jdGlvbigpe3ZhciBzLHI9SC51UCh0aGlzLmIpCmlmKHR5cGVvZiByIT09Im51bWJlciIpcmV0
+dXJuIHIuSigpCmlmKHI8MClyZXR1cm4iOiBpbmRleCBtdXN0IG5vdCBiZSBuZWdhdGl2ZSIKcz10aGlz
+LmYKaWYocz09PTApcmV0dXJuIjogbm8gaW5kaWNlcyBhcmUgdmFsaWQiCnJldHVybiI6IGluZGV4IHNo
+b3VsZCBiZSBsZXNzIHRoYW4gIitILkVqKHMpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZn19
+ClAubXAucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhpcyxq
+PXt9LGk9bmV3IFAuUm4oIiIpCmouYT0iIgpzPWsuYwpmb3Iocj1zLmxlbmd0aCxxPTAscD0iIixvPSIi
+O3E8cjsrK3Esbz0iLCAiKXtuPXNbcV0KaS5hPXArbwpwPWkuYSs9UC5wKG4pCmouYT0iLCAifWsuZC5L
+KDAsbmV3IFAuV0YoaixpKSkKbT1QLnAoay5hKQpsPWkudygwKQpyPSJOb1N1Y2hNZXRob2RFcnJvcjog
+bWV0aG9kIG5vdCBmb3VuZDogJyIrSC5FaihrLmIuYSkrIidcblJlY2VpdmVyOiAiK20rIlxuQXJndW1l
+bnRzOiBbIitsKyJdIgpyZXR1cm4gcn19ClAudWIucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1
+cm4iVW5zdXBwb3J0ZWQgb3BlcmF0aW9uOiAiK3RoaXMuYX19ClAuZHMucHJvdG90eXBlPXsKdzpmdW5j
+dGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMhPW51bGw/IlVuaW1wbGVtZW50ZWRFcnJvcjogIitz
+OiJVbmltcGxlbWVudGVkRXJyb3IifX0KUC5sai5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVy
+biJCYWQgc3RhdGU6ICIrdGhpcy5hfX0KUC5VVi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBz
+PXRoaXMuYQppZihzPT1udWxsKXJldHVybiJDb25jdXJyZW50IG1vZGlmaWNhdGlvbiBkdXJpbmcgaXRl
+cmF0aW9uLiIKcmV0dXJuIkNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uIGR1cmluZyBpdGVyYXRpb246ICIr
+UC5wKHMpKyIuIn19ClAuazUucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iT3V0IG9mIE1l
+bW9yeSJ9LApnSUk6ZnVuY3Rpb24oKXtyZXR1cm4gbnVsbH0sCiRpWFM6MX0KUC5LWS5wcm90b3R5cGU9
+ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJTdGFjayBPdmVyZmxvdyJ9LApnSUk6ZnVuY3Rpb24oKXtyZXR1
+cm4gbnVsbH0sCiRpWFM6MX0KUC5jLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5h
+CnJldHVybiBzPT1udWxsPyJSZWFkaW5nIHN0YXRpYyB2YXJpYWJsZSBkdXJpbmcgaXRzIGluaXRpYWxp
+emF0aW9uIjoiUmVhZGluZyBzdGF0aWMgdmFyaWFibGUgJyIrcysiJyBkdXJpbmcgaXRzIGluaXRpYWxp
+emF0aW9uIn19ClAuQ0QucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iRXhjZXB0aW9uOiAi
+K3RoaXMuYX0sCiRpUno6MX0KUC5hRS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxw
+LG8sbixtLGwsayxqLGksaCxnPXRoaXMuYSxmPWchPW51bGwmJiIiIT09Zz8iRm9ybWF0RXhjZXB0aW9u
+OiAiK0guRWooZyk6IkZvcm1hdEV4Y2VwdGlvbiIsZT10aGlzLmMsZD10aGlzLmIKaWYodHlwZW9mIGQ9
+PSJzdHJpbmciKXtpZihlIT1udWxsKXM9ZTwwfHxlPmQubGVuZ3RoCmVsc2Ugcz0hMQppZihzKWU9bnVs
+bAppZihlPT1udWxsKXtpZihkLmxlbmd0aD43OClkPUMueEIuTmooZCwwLDc1KSsiLi4uIgpyZXR1cm4g
+ZisiXG4iK2R9Zm9yKHI9MSxxPTAscD0hMSxvPTA7bzxlOysrbyl7bj1DLnhCLlcoZCxvKQppZihuPT09
+MTApe2lmKHEhPT1vfHwhcCkrK3IKcT1vKzEKcD0hMX1lbHNlIGlmKG49PT0xMyl7KytyCnE9bysxCnA9
+ITB9fWY9cj4xP2YrKCIgKGF0IGxpbmUgIityKyIsIGNoYXJhY3RlciAiKyhlLXErMSkrIilcbiIpOmYr
+KCIgKGF0IGNoYXJhY3RlciAiKyhlKzEpKyIpXG4iKQptPWQubGVuZ3RoCmZvcihvPWU7bzxtOysrbyl7
+bj1DLnhCLk8oZCxvKQppZihuPT09MTB8fG49PT0xMyl7bT1vCmJyZWFrfX1pZihtLXE+NzgpaWYoZS1x
+PDc1KXtsPXErNzUKaz1xCmo9IiIKaT0iLi4uIn1lbHNle2lmKG0tZTw3NSl7az1tLTc1Cmw9bQppPSIi
+fWVsc2V7az1lLTM2Cmw9ZSszNgppPSIuLi4ifWo9Ii4uLiJ9ZWxzZXtsPW0Kaz1xCmo9IiIKaT0iIn1o
+PUMueEIuTmooZCxrLGwpCnJldHVybiBmK2oraCtpKyJcbiIrQy54Qi5UKCIgIixlLWsrai5sZW5ndGgp
+KyJeXG4ifWVsc2UgcmV0dXJuIGUhPW51bGw/ZisoIiAoYXQgb2Zmc2V0ICIrSC5FaihlKSsiKSIpOmZ9
+LAokaVJ6OjF9ClAuY1gucHJvdG90eXBlPXsKZHI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5HSih0aGlz
+LEguTGgodGhpcykuQygiY1guRSIpLGIpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhp
+cykKcmV0dXJuIEguSzEodGhpcyxzLktxKGMpLkMoIjEoY1guRSkiKS5hKGIpLHMuQygiY1guRSIpLGMp
+fSwKZXY6ZnVuY3Rpb24oYSxiKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVybiBuZXcgSC5VNSh0aGlzLHMu
+QygiYTIoY1guRSkiKS5hKGIpLHMuQygiVTU8Y1guRT4iKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVy
+biBQLlkxKHRoaXMsYixILkxoKHRoaXMpLkMoImNYLkUiKSl9LApicjpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy50dChhLCEwKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5nbSh0aGlzKQpmb3Iocz0w
+O3IuRigpOykrK3MKcmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIXRoaXMuZ20odGhpcyku
+RigpfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdsMCh0aGlzKX0sCmVSOmZ1bmN0aW9uKGEs
+Yil7cmV0dXJuIEguYksodGhpcyxiLEguTGgodGhpcykuQygiY1guRSIpKX0sCmdyODpmdW5jdGlvbihh
+KXt2YXIgcyxyPXRoaXMuZ20odGhpcykKaWYoIXIuRigpKXRocm93IEguYihILldwKCkpCnM9ci5nbCgp
+CmlmKHIuRigpKXRocm93IEguYihILkFtKCkpCnJldHVybiBzfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBz
+LHIscQpQLmsxKGIsImluZGV4IikKZm9yKHM9dGhpcy5nbSh0aGlzKSxyPTA7cy5GKCk7KXtxPXMuZ2wo
+KQppZihiPT09cilyZXR1cm4gcTsrK3J9dGhyb3cgSC5iKFAuQ2YoYix0aGlzLCJpbmRleCIsbnVsbCxy
+KSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLkVQKHRoaXMsIigiLCIpIil9fQpQLkFuLnByb3RvdHlw
+ZT17fQpQLk4zLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk1hcEVudHJ5KCIrSC5FaihK
+LmoodGhpcy5hKSkrIjogIitILkVqKEouaih0aGlzLmIpKSsiKSJ9fQpQLmM4LnByb3RvdHlwZT17Cmdp
+TzpmdW5jdGlvbihhKXtyZXR1cm4gUC5NaC5wcm90b3R5cGUuZ2lPLmNhbGwoQy5qTix0aGlzKX0sCnc6
+ZnVuY3Rpb24oYSl7cmV0dXJuIm51bGwifX0KUC5NaC5wcm90b3R5cGU9e2NvbnN0cnVjdG9yOlAuTWgs
+JGlNaDoxLApETjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzPT09Yn0sCmdpTzpmdW5jdGlvbihhKXty
+ZXR1cm4gSC5lUSh0aGlzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWoo
+SC5NKHRoaXMpKSsiJyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKHRo
+aXMsYi5nV2EoKSxiLmduZCgpLGIuZ1ZtKCkpKX0sCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIHRo
+aXMudyh0aGlzKX19ClAuWmQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iIn0sCiRpR3o6
+MX0KUC5Sbi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnc6
+ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwKJGlC
+TDoxfQpQLm4xLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5KLmEoYSkK
+SC5oKGIpCnM9Si5yWShiKS5PWShiLCI9IikKaWYocz09PS0xKXtpZihiIT09IiIpYS5ZNSgwLFAua3Uo
+YiwwLGIubGVuZ3RoLHRoaXMuYSwhMCksIiIpfWVsc2UgaWYocyE9PTApe3I9Qy54Qi5OaihiLDAscykK
+cT1DLnhCLnluKGIscysxKQpwPXRoaXMuYQphLlk1KDAsUC5rdShyLDAsci5sZW5ndGgscCwhMCksUC5r
+dShxLDAscS5sZW5ndGgscCwhMCkpfXJldHVybiBhfSwKJFM6NDF9ClAuY1MucHJvdG90eXBlPXsKJDI6
+ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxsZWdhbCBJUHY0IGFkZHJlc3MsICIrYSx0aGlz
+LmEsYikpfSwKJFM6MjF9ClAuVkMucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIo
+UC5ycigiSWxsZWdhbCBJUHY2IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJDE6ZnVuY3Rpb24oYSl7
+cmV0dXJuIHRoaXMuJDIoYSxudWxsKX0sCiRTOjQ2fQpQLkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9u
+KGEsYil7dmFyIHMKaWYoYi1hPjQpdGhpcy5hLiQyKCJhbiBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFp
+biBhIG1heGltdW0gb2YgNCBoZXggZGlnaXRzIixhKQpzPVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwx
+NikKaWYoczwwfHxzPjY1NTM1KXRoaXMuYS4kMigiZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdl
+IG9mIGAweDAuLjB4RkZGRmAiLGEpCnJldHVybiBzfSwKJFM6NTF9ClAuRG4ucHJvdG90eXBlPXsKZ25E
+OmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlmKCFvLnkpe3M9by5hCnI9cy5sZW5ndGghPT0w
+P3MrIjoiOiIiCnE9by5jCnA9cT09bnVsbAppZighcHx8cz09PSJmaWxlIil7cz1yKyIvLyIKcj1vLmIK
+aWYoci5sZW5ndGghPT0wKXM9cytyKyJAIgppZighcClzKz1xCnI9by5kCmlmKHIhPW51bGwpcz1zKyI6
+IitILkVqKHIpfWVsc2Ugcz1yCnMrPW8uZQpyPW8uZgppZihyIT1udWxsKXM9cysiPyIrcgpyPW8ucgpp
+ZihyIT1udWxsKXM9cysiIyIrcgppZihvLnkpdGhyb3cgSC5iKEguR1EoIl90ZXh0IikpCm8ueD1zLmNo
+YXJDb2RlQXQoMCk9PTA/czpzCm8ueT0hMH1yZXR1cm4gby54fSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMs
+cixxPXRoaXMKaWYoIXEuUSl7cz1xLmUKaWYocy5sZW5ndGghPT0wJiZDLnhCLlcocywwKT09PTQ3KXM9
+Qy54Qi55bihzLDEpCnI9cy5sZW5ndGg9PT0wP0MueEQ6UC5BRihuZXcgSC5sSihILlZNKHMuc3BsaXQo
+Ii8iKSx0LnMpLHQuZE8uYShQLlBIKCkpLHQuZG8pLHQuTikKaWYocS5RKXRocm93IEguYihILkdRKCJw
+YXRoU2VnbWVudHMiKSkKcS5zS3AocikKcS5RPSEwfXJldHVybiBxLnp9LApnaU86ZnVuY3Rpb24oYSl7
+dmFyIHMscj10aGlzCmlmKCFyLmN4KXtzPUouaGYoci5nbkQoKSkKaWYoci5jeCl0aHJvdyBILmIoSC5H
+USgiaGFzaENvZGUiKSkKci5jaD1zCnIuY3g9ITB9cmV0dXJuIHIuY2h9LApnaFk6ZnVuY3Rpb24oKXt2
+YXIgcyxyPXRoaXMKaWYoIXIuZGIpe3M9UC5XWChyLmd0UCgpKQppZihyLmRiKXRocm93IEguYihILkdR
+KCJxdWVyeVBhcmFtZXRlcnMiKSkKci5zTk0obmV3IFAuR2oocyx0LmR3KSkKci5kYj0hMH1yZXR1cm4g
+ci5jeX0sCmdrdTpmdW5jdGlvbigpe3JldHVybiB0aGlzLmJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9
+dGhpcy5jCmlmKHM9PW51bGwpcmV0dXJuIiIKaWYoQy54Qi5uKHMsIlsiKSlyZXR1cm4gQy54Qi5Oaihz
+LDEscy5sZW5ndGgtMSkKcmV0dXJuIHN9LApndHA6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCnJldHVy
+biBzPT1udWxsP1Aud0sodGhpcy5hKTpzfSwKZ3RQOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5mCnJldHVy
+biBzPT1udWxsPyIiOnN9LApnS2E6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLnIKcmV0dXJuIHM9PW51bGw/
+IiI6c30sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGo9dGhpcwp0LmM5LmEo
+YikKcz1qLmEKcj1zPT09ImZpbGUiCnE9ai5iCnA9ai5kCm89ai5jCmlmKCEobyE9bnVsbCkpbz1xLmxl
+bmd0aCE9PTB8fHAhPW51bGx8fHI/IiI6bnVsbApuPWouZQppZighciltPW8hPW51bGwmJm4ubGVuZ3Ro
+IT09MAplbHNlIG09ITAKaWYobSYmIUMueEIubihuLCIvIikpbj0iLyIrbgpsPW4Kaz1QLmxlKG51bGws
+MCwwLGIpCnJldHVybiBuZXcgUC5EbihzLHEsbyxwLGwsayxqLnIpfSwKSmg6ZnVuY3Rpb24oYSxiKXt2
+YXIgcyxyLHEscCxvLG4KZm9yKHM9MCxyPTA7Qy54Qi5RaShiLCIuLi8iLHIpOyl7cis9MzsrK3N9cT1D
+LnhCLmNuKGEsIi8iKQp3aGlsZSghMCl7aWYoIShxPjAmJnM+MCkpYnJlYWsKcD1DLnhCLlBrKGEsIi8i
+LHEtMSkKaWYocDwwKWJyZWFrCm89cS1wCm49byE9PTIKaWYoIW58fG89PT0zKWlmKEMueEIuTyhhLHAr
+MSk9PT00NiluPSFufHxDLnhCLk8oYSxwKzIpPT09NDYKZWxzZSBuPSExCmVsc2Ugbj0hMQppZihuKWJy
+ZWFrOy0tcwpxPXB9cmV0dXJuIEMueEIuaTcoYSxxKzEsbnVsbCxDLnhCLnluKGIsci0zKnMpKX0sClpJ
+OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLm1TKFAuaEsoYSkpfSwKbVM6ZnVuY3Rpb24oYSl7dmFyIHMs
+cixxLHAsbyxuLG0sbCxrLGo9dGhpcyxpPW51bGwKaWYoYS5nRmkoKS5sZW5ndGghPT0wKXtzPWEuZ0Zp
+KCkKaWYoYS5nY2ooKSl7cj1hLmdrdSgpCnE9YS5nSmYoYSkKcD1hLmd4QSgpP2EuZ3RwKGEpOml9ZWxz
+ZXtwPWkKcT1wCnI9IiJ9bz1QLnhlKGEuZ0lpKGEpKQpuPWEuZ1FEKCk/YS5ndFAoKTppfWVsc2V7cz1q
+LmEKaWYoYS5nY2ooKSl7cj1hLmdrdSgpCnE9YS5nSmYoYSkKcD1QLndCKGEuZ3hBKCk/YS5ndHAoYSk6
+aSxzKQpvPVAueGUoYS5nSWkoYSkpCm49YS5nUUQoKT9hLmd0UCgpOml9ZWxzZXtyPWouYgpxPWouYwpw
+PWouZAppZihhLmdJaShhKT09PSIiKXtvPWouZQpuPWEuZ1FEKCk/YS5ndFAoKTpqLmZ9ZWxzZXtpZihh
+Lmd0VCgpKW89UC54ZShhLmdJaShhKSkKZWxzZXttPWouZQppZihtLmxlbmd0aD09PTApaWYocT09bnVs
+bClvPXMubGVuZ3RoPT09MD9hLmdJaShhKTpQLnhlKGEuZ0lpKGEpKQplbHNlIG89UC54ZSgiLyIrYS5n
+SWkoYSkpCmVsc2V7bD1qLkpoKG0sYS5nSWkoYSkpCms9cy5sZW5ndGg9PT0wCmlmKCFrfHxxIT1udWxs
+fHxDLnhCLm4obSwiLyIpKW89UC54ZShsKQplbHNlIG89UC53RihsLCFrfHxxIT1udWxsKX19bj1hLmdR
+RCgpP2EuZ3RQKCk6aX19fXJldHVybiBuZXcgUC5EbihzLHIscSxwLG8sbixhLmdaOCgpP2EuZ0thKCk6
+aSl9LApnY2o6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5jIT1udWxsfSwKZ3hBOmZ1bmN0aW9uKCl7cmV0
+dXJuIHRoaXMuZCE9bnVsbH0sCmdRRDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmYhPW51bGx9LApnWjg6
+ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yIT1udWxsfSwKZ3RUOmZ1bmN0aW9uKCl7cmV0dXJuIEMueEIu
+bih0aGlzLmUsIi8iKX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5hCmlmKHEhPT0iIiYm
+cSE9PSJmaWxlIil0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBh
+ICIrcSsiIFVSSSIpKQppZihyLmd0UCgpIT09IiIpdGhyb3cgSC5iKFAuTDQodS5pKSkKaWYoci5nS2Eo
+KSE9PSIiKXRocm93IEguYihQLkw0KHUubCkpCnE9JC53USgpCmlmKEgub1QocSkpcT1QLm1uKHIpCmVs
+c2V7aWYoci5jIT1udWxsJiZyLmdKZihyKSE9PSIiKUgudihQLkw0KHUuaikpCnM9ci5nRmooKQpQLmtF
+KHMsITEpCnE9UC52ZyhDLnhCLm4oci5lLCIvIik/Ii8iOiIiLHMsIi8iKQpxPXEuY2hhckNvZGVBdCgw
+KT09MD9xOnF9cmV0dXJuIHF9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmduRCgpfSwKRE46ZnVu
+Y3Rpb24oYSxiKXt2YXIgcz10aGlzCmlmKGI9PW51bGwpcmV0dXJuITEKaWYocz09PWIpcmV0dXJuITAK
+cmV0dXJuIHQuZEQuYihiKSYmcy5hPT09Yi5nRmkoKSYmcy5jIT1udWxsPT09Yi5nY2ooKSYmcy5iPT09
+Yi5na3UoKSYmcy5nSmYocyk9PT1iLmdKZihiKSYmcy5ndHAocyk9PT1iLmd0cChiKSYmcy5lPT09Yi5n
+SWkoYikmJnMuZiE9bnVsbD09PWIuZ1FEKCkmJnMuZ3RQKCk9PT1iLmd0UCgpJiZzLnIhPW51bGw9PT1i
+LmdaOCgpJiZzLmdLYSgpPT09Yi5nS2EoKX0sCnNLcDpmdW5jdGlvbihhKXt0aGlzLno9dC5iay5hKGEp
+fSwKc05NOmZ1bmN0aW9uKGEpe3RoaXMuY3k9dC5jWi5hKGEpfSwKJGlpRDoxLApnRmk6ZnVuY3Rpb24o
+KXtyZXR1cm4gdGhpcy5hfSwKZ0lpOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmV9fQpQLlJaLnByb3Rv
+dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBQLmVQKEMuWkosSC5oKGEpLEMueE0sITEpfSwKJFM6
+NX0KUC5NRS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMuYixyPXRoaXMuYQpz
+LmErPXIuYQpyLmE9IiYiCnI9cy5hKz1ILkVqKFAuZVAoQy5GMyxhLEMueE0sITApKQppZihiIT1udWxs
+JiZiLmxlbmd0aCE9PTApe3MuYT1yKyI9IgpzLmErPUguRWooUC5lUChDLkYzLGIsQy54TSwhMCkpfX0s
+CiRTOjIyfQpQLnk1LnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILmgoYSkKaWYo
+Yj09bnVsbHx8dHlwZW9mIGI9PSJzdHJpbmciKXRoaXMuYS4kMihhLEguayhiKSkKZWxzZSBmb3Iocz1K
+LklUKHQudS5hKGIpKSxyPXRoaXMuYTtzLkYoKTspci4kMihhLEguaChzLmdsKCkpKX0sCiRTOjEzfQpQ
+LlBFLnByb3RvdHlwZT17CmdsUjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89dGhpcyxuPW51bGwsbT1v
+LmMKaWYobT09bnVsbCl7bT1vLmIKaWYoMD49bS5sZW5ndGgpcmV0dXJuIEguT0gobSwwKQpzPW8uYQpt
+PW1bMF0rMQpyPUMueEIuWFUocywiPyIsbSkKcT1zLmxlbmd0aAppZihyPj0wKXtwPVAuUEkocyxyKzEs
+cSxDLlZDLCExKQpxPXJ9ZWxzZSBwPW4KbT1vLmM9bmV3IFAucWUoImRhdGEiLCIiLG4sbixQLlBJKHMs
+bSxxLEMuV2QsITEpLHAsbil9cmV0dXJuIG19LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5iCmlm
+KDA+PXIubGVuZ3RoKXJldHVybiBILk9IKHIsMCkKcz10aGlzLmEKcmV0dXJuIHJbMF09PT0tMT8iZGF0
+YToiK3M6c319ClAueUkucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmEKaWYo
+YT49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxhKQpzPXNbYV0KQy5OQS5kdShzLDAsOTYsYikKcmV0dXJu
+IHN9LAokUzoyM30KUC5jNi5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxCmZv
+cihzPWIubGVuZ3RoLHI9MDtyPHM7KytyKXtxPUMueEIuVyhiLHIpXjk2CmlmKHE+PTk2KXJldHVybiBI
+Lk9IKGEscSkKYVtxXT1jfX0sCiRTOjE0fQpQLnFkLnByb3RvdHlwZT17CiQzOmZ1bmN0aW9uKGEsYixj
+KXt2YXIgcyxyLHEKZm9yKHM9Qy54Qi5XKGIsMCkscj1DLnhCLlcoYiwxKTtzPD1yOysrcyl7cT0oc145
+Nik+Pj4wCmlmKHE+PTk2KXJldHVybiBILk9IKGEscSkKYVtxXT1jfX0sCiRTOjE0fQpQLlVmLnByb3Rv
+dHlwZT17CmdjajpmdW5jdGlvbigpe3JldHVybiB0aGlzLmM+MH0sCmd4QTpmdW5jdGlvbigpe3JldHVy
+biB0aGlzLmM+MCYmdGhpcy5kKzE8dGhpcy5lfSwKZ1FEOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZjx0
+aGlzLnJ9LApnWjg6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yPHRoaXMuYS5sZW5ndGh9LApnTnc6ZnVu
+Y3Rpb24oKXtyZXR1cm4gdGhpcy5iPT09NCYmQy54Qi5uKHRoaXMuYSwiZmlsZSIpfSwKZ1daOmZ1bmN0
+aW9uKCl7cmV0dXJuIHRoaXMuYj09PTQmJkMueEIubih0aGlzLmEsImh0dHAiKX0sCmdSZTpmdW5jdGlv
+bigpe3JldHVybiB0aGlzLmI9PT01JiZDLnhCLm4odGhpcy5hLCJodHRwcyIpfSwKZ3RUOmZ1bmN0aW9u
+KCl7cmV0dXJuIEMueEIuUWkodGhpcy5hLCIvIix0aGlzLmUpfSwKZ0ZpOmZ1bmN0aW9uKCl7dmFyIHM9
+dGhpcy54CnJldHVybiBzPT1udWxsP3RoaXMueD10aGlzLlUyKCk6c30sClUyOmZ1bmN0aW9uKCl7dmFy
+IHM9dGhpcyxyPXMuYgppZihyPD0wKXJldHVybiIiCmlmKHMuZ1daKCkpcmV0dXJuImh0dHAiCmlmKHMu
+Z1JlKCkpcmV0dXJuImh0dHBzIgppZihzLmdOdygpKXJldHVybiJmaWxlIgppZihyPT09NyYmQy54Qi5u
+KHMuYSwicGFja2FnZSIpKXJldHVybiJwYWNrYWdlIgpyZXR1cm4gQy54Qi5OaihzLmEsMCxyKX0sCmdr
+dTpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYyxyPXRoaXMuYiszCnJldHVybiBzPnI/Qy54Qi5Oaih0aGlz
+LmEscixzLTEpOiIifSwKZ0pmOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYwpyZXR1cm4gcz4wP0MueEIu
+TmoodGhpcy5hLHMsdGhpcy5kKToiIn0sCmd0cDpmdW5jdGlvbihhKXt2YXIgcz10aGlzCmlmKHMuZ3hB
+KCkpcmV0dXJuIFAuUUEoQy54Qi5OaihzLmEscy5kKzEscy5lKSxudWxsKQppZihzLmdXWigpKXJldHVy
+biA4MAppZihzLmdSZSgpKXJldHVybiA0NDMKcmV0dXJuIDB9LApnSWk6ZnVuY3Rpb24oYSl7cmV0dXJu
+IEMueEIuTmoodGhpcy5hLHRoaXMuZSx0aGlzLmYpfSwKZ3RQOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5m
+LHI9dGhpcy5yCnJldHVybiBzPHI/Qy54Qi5Oaih0aGlzLmEscysxLHIpOiIifSwKZ0thOmZ1bmN0aW9u
+KCl7dmFyIHM9dGhpcy5yLHI9dGhpcy5hCnJldHVybiBzPHIubGVuZ3RoP0MueEIueW4ocixzKzEpOiIi
+fSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMuZSxwPXRoaXMuZixvPXRoaXMuYQppZihDLnhC
+LlFpKG8sIi8iLHEpKSsrcQppZihxPT09cClyZXR1cm4gQy54RApzPUguVk0oW10sdC5zKQpmb3Iocj1x
+O3I8cDsrK3IpaWYoQy54Qi5PKG8scik9PT00Nyl7Qy5ObS5pKHMsQy54Qi5OaihvLHEscikpCnE9cisx
+fUMuTm0uaShzLEMueEIuTmoobyxxLHApKQpyZXR1cm4gUC5BRihzLHQuTil9LApnaFk6ZnVuY3Rpb24o
+KXtpZih0aGlzLmY+PXRoaXMucilyZXR1cm4gQy5DTQpyZXR1cm4gbmV3IFAuR2ooUC5XWCh0aGlzLmd0
+UCgpKSx0LmR3KX0sCmtYOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZCsxCnJldHVybiBzK2EubGVuZ3Ro
+PT09dGhpcy5lJiZDLnhCLlFpKHRoaXMuYSxhLHMpfSwKTjk6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9
+cy5yLHE9cy5hCmlmKHI+PXEubGVuZ3RoKXJldHVybiBzCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKHEs
+MCxyKSxzLmIscy5jLHMuZCxzLmUscy5mLHIscy54KX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMscixx
+LHAsbyxuLG0sbCxrLGosaT10aGlzLGg9bnVsbAp0LmM5LmEoYikKcz1pLmdGaSgpCnI9cz09PSJmaWxl
+IgpxPWkuYwpwPXE+MD9DLnhCLk5qKGkuYSxpLmIrMyxxKToiIgpvPWkuZ3hBKCk/aS5ndHAoaSk6aApx
+PWkuYwppZihxPjApbj1DLnhCLk5qKGkuYSxxLGkuZCkKZWxzZSBuPXAubGVuZ3RoIT09MHx8byE9bnVs
+bHx8cj8iIjpoCnE9aS5hCm09Qy54Qi5OaihxLGkuZSxpLmYpCmlmKCFyKWw9biE9bnVsbCYmbS5sZW5n
+dGghPT0wCmVsc2UgbD0hMAppZihsJiYhQy54Qi5uKG0sIi8iKSltPSIvIittCms9UC5sZShoLDAsMCxi
+KQpsPWkucgpqPWw8cS5sZW5ndGg/Qy54Qi55bihxLGwrMSk6aApyZXR1cm4gbmV3IFAuRG4ocyxwLG4s
+byxtLGssail9LApaSTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5tUyhQLmhLKGEpKX0sCm1TOmZ1bmN0
+aW9uKGEpe2lmKGEgaW5zdGFuY2VvZiBQLlVmKXJldHVybiB0aGlzLnUxKHRoaXMsYSkKcmV0dXJuIHRo
+aXMudnMoKS5tUyhhKX0sCnUxOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxo
+LGc9Yi5iCmlmKGc+MClyZXR1cm4gYgpzPWIuYwppZihzPjApe3I9YS5iCmlmKHI8PTApcmV0dXJuIGIK
+aWYoYS5nTncoKSlxPWIuZSE9PWIuZgplbHNlIGlmKGEuZ1daKCkpcT0hYi5rWCgiODAiKQplbHNlIHE9
+IWEuZ1JlKCl8fCFiLmtYKCI0NDMiKQppZihxKXtwPXIrMQpyZXR1cm4gbmV3IFAuVWYoQy54Qi5Oaihh
+LmEsMCxwKStDLnhCLnluKGIuYSxnKzEpLHIscytwLGIuZCtwLGIuZStwLGIuZitwLGIucitwLGEueCl9
+ZWxzZSByZXR1cm4gdGhpcy52cygpLm1TKGIpfW89Yi5lCmc9Yi5mCmlmKG89PT1nKXtzPWIucgppZihn
+PHMpe3I9YS5mCnA9ci1nCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4oYi5h
+LGcpLGEuYixhLmMsYS5kLGEuZSxnK3AscytwLGEueCl9Zz1iLmEKaWYoczxnLmxlbmd0aCl7cj1hLnIK
+cmV0dXJuIG5ldyBQLlVmKEMueEIuTmooYS5hLDAscikrQy54Qi55bihnLHMpLGEuYixhLmMsYS5kLGEu
+ZSxhLmYscysoci1zKSxhLngpfXJldHVybiBhLk45KCl9cz1iLmEKaWYoQy54Qi5RaShzLCIvIixvKSl7
+cj1hLmUKcD1yLW8KcmV0dXJuIG5ldyBQLlVmKEMueEIuTmooYS5hLDAscikrQy54Qi55bihzLG8pLGEu
+YixhLmMsYS5kLHIsZytwLGIucitwLGEueCl9bj1hLmUKbT1hLmYKaWYobj09PW0mJmEuYz4wKXtmb3Io
+O0MueEIuUWkocywiLi4vIixvKTspbys9MwpwPW4tbysxCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEu
+YSwwLG4pKyIvIitDLnhCLnluKHMsbyksYS5iLGEuYyxhLmQsbixnK3AsYi5yK3AsYS54KX1sPWEuYQpm
+b3Ioaz1uO0MueEIuUWkobCwiLi4vIixrKTspays9MwpqPTAKd2hpbGUoITApe2k9byszCmlmKCEoaTw9
+ZyYmQy54Qi5RaShzLCIuLi8iLG8pKSlicmVhazsrK2oKbz1pfWZvcihoPSIiO20+azspey0tbQppZihD
+LnhCLk8obCxtKT09PTQ3KXtpZihqPT09MCl7aD0iLyIKYnJlYWt9LS1qCmg9Ii8ifX1pZihtPT09ayYm
+YS5iPD0wJiYhQy54Qi5RaShsLCIvIixuKSl7by09aiozCmg9IiJ9cD1tLW8raC5sZW5ndGgKcmV0dXJu
+IG5ldyBQLlVmKEMueEIuTmoobCwwLG0pK2grQy54Qi55bihzLG8pLGEuYixhLmMsYS5kLG4sZytwLGIu
+citwLGEueCl9LAp0NDpmdW5jdGlvbigpe3ZhciBzLHIscSxwPXRoaXMKaWYocC5iPj0wJiYhcC5nTnco
+KSl0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBhICIrcC5nRmko
+KSsiIFVSSSIpKQpzPXAuZgpyPXAuYQppZihzPHIubGVuZ3RoKXtpZihzPHAucil0aHJvdyBILmIoUC5M
+NCh1LmkpKQp0aHJvdyBILmIoUC5MNCh1LmwpKX1xPSQud1EoKQppZihILm9UKHEpKXM9UC5tbihwKQpl
+bHNle2lmKHAuYzxwLmQpSC52KFAuTDQodS5qKSkKcz1DLnhCLk5qKHIscC5lLHMpfXJldHVybiBzfSwK
+Z2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMueQpyZXR1cm4gcz09bnVsbD90aGlzLnk9Qy54Qi5naU8o
+dGhpcy5hKTpzfSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJldHVybiExCmlmKHRoaXM9PT1i
+KXJldHVybiEwCnJldHVybiB0LmRELmIoYikmJnRoaXMuYT09PWIudygwKX0sCnZzOmZ1bmN0aW9uKCl7
+dmFyIHM9dGhpcyxyPW51bGwscT1zLmdGaSgpLHA9cy5na3UoKSxvPXMuYz4wP3MuZ0pmKHMpOnIsbj1z
+Lmd4QSgpP3MuZ3RwKHMpOnIsbT1zLmEsbD1zLmYsaz1DLnhCLk5qKG0scy5lLGwpLGo9cy5yCmw9bDxq
+P3MuZ3RQKCk6cgpyZXR1cm4gbmV3IFAuRG4ocSxwLG8sbixrLGwsajxtLmxlbmd0aD9zLmdLYSgpOnIp
+fSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKJGlpRDoxfQpQLnFlLnByb3RvdHlwZT17fQpX
+LnFFLnByb3RvdHlwZT17fQpXLkdoLnByb3RvdHlwZT17CnNMVTpmdW5jdGlvbihhLGIpe2EuaHJlZj1i
+fSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfSwKJGlHaDoxfQpXLmZZLnByb3RvdHlwZT17
+Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX19ClcubkIucHJvdG90eXBlPXskaW5COjF9Clcu
+QXoucHJvdG90eXBlPXskaUF6OjF9ClcuUVAucHJvdG90eXBlPXskaVFQOjF9ClcubngucHJvdG90eXBl
+PXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy5vSi5wcm90b3R5cGU9ewpnQTpmdW5j
+dGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLmlkLnByb3RvdHlwZT17fQpXLlFGLnByb3RvdHlwZT17
+fQpXLk5oLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX19ClcuYWUucHJv
+dG90eXBlPXsKRGM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYS5jcmVhdGVIVE1MRG9jdW1lbnQoYil9fQpX
+LklCLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj1hLmxlZnQKci50b1N0cmluZwpyPSJS
+ZWN0YW5nbGUgKCIrSC5FaihyKSsiLCAiCnM9YS50b3AKcy50b1N0cmluZwpzPXIrSC5FaihzKSsiKSAi
+CnI9YS53aWR0aApyLnRvU3RyaW5nCnI9cytILkVqKHIpKyIgeCAiCnM9YS5oZWlnaHQKcy50b1N0cmlu
+ZwpyZXR1cm4gcitILkVqKHMpfSwKRE46ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKGI9PW51bGwpcmV0
+dXJuITEKaWYodC5xLmIoYikpe3M9YS5sZWZ0CnMudG9TdHJpbmcKcj1iLmxlZnQKci50b1N0cmluZwpp
+ZihzPT09cil7cz1hLnRvcApzLnRvU3RyaW5nCnI9Yi50b3AKci50b1N0cmluZwppZihzPT09cil7cz1h
+LndpZHRoCnMudG9TdHJpbmcKcj1iLndpZHRoCnIudG9TdHJpbmcKaWYocz09PXIpe3M9YS5oZWlnaHQK
+cy50b1N0cmluZwpyPWIuaGVpZ2h0CnIudG9TdHJpbmcKcj1zPT09cgpzPXJ9ZWxzZSBzPSExfWVsc2Ug
+cz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSExCnJldHVybiBzfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
+cSxwPWEubGVmdApwLnRvU3RyaW5nCnA9Qy5DRC5naU8ocCkKcz1hLnRvcApzLnRvU3RyaW5nCnM9Qy5D
+RC5naU8ocykKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1DLkNELmdpTyhyKQpxPWEuaGVpZ2h0CnEudG9T
+dHJpbmcKcmV0dXJuIFcuckUocCxzLHIsQy5DRC5naU8ocSkpfSwKJGl0bjoxfQpXLm43LnByb3RvdHlw
+ZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19Clcud3oucHJvdG90eXBlPXsKZ0E6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMKSC51UChi
+KQpzPXRoaXMuYQppZihiPDB8fGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHRoaXMu
+JHRpLmMuYShzW2JdKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt0aGlzLiR0aS5jLmEoYykKdGhyb3cgSC5i
+KFAuTDQoIkNhbm5vdCBtb2RpZnkgbGlzdCIpKX19ClcuY3YucHJvdG90eXBlPXsKZ1FnOmZ1bmN0aW9u
+KGEpe3JldHVybiBuZXcgVy5pNyhhKX0sCmdQOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5JNChhKX0s
+CnNQOmZ1bmN0aW9uKGEsYil7dmFyIHMKdC5RLmEoYikKcz10aGlzLmdQKGEpCnMuVjEoMCkKcy5GVigw
+LGIpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sb2NhbE5hbWV9LApGRjpmdW5jdGlvbihhKXt2YXIg
+cz0hIWEuc2Nyb2xsSW50b1ZpZXdJZk5lZWRlZAppZihzKWEuc2Nyb2xsSW50b1ZpZXdJZk5lZWRlZCgp
+CmVsc2UgYS5zY3JvbGxJbnRvVmlldygpfSwKbno6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyPXRo
+aXMucjYoYSxjLGQsZSkKc3dpdGNoKGIudG9Mb3dlckNhc2UoKSl7Y2FzZSJiZWZvcmViZWdpbiI6cz1h
+LnBhcmVudE5vZGUKcy50b1N0cmluZwpKLkVoKHMscixhKQpicmVhawpjYXNlImFmdGVyYmVnaW4iOnM9
+YS5jaGlsZE5vZGVzCnRoaXMubUsoYSxyLHMubGVuZ3RoPjA/c1swXTpudWxsKQpicmVhawpjYXNlImJl
+Zm9yZWVuZCI6YS5hcHBlbmRDaGlsZChyKQpicmVhawpjYXNlImFmdGVyZW5kIjpzPWEucGFyZW50Tm9k
+ZQpzLnRvU3RyaW5nCkouRWgocyxyLGEubmV4dFNpYmxpbmcpCmJyZWFrCmRlZmF1bHQ6SC52KFAueFko
+IkludmFsaWQgcG9zaXRpb24gIitiKSl9fSwKcjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAK
+aWYoYz09bnVsbCl7aWYoZD09bnVsbCl7cz0kLmx0CmlmKHM9PW51bGwpe3M9SC5WTShbXSx0LnYpCnI9
+bmV3IFcudkQocykKQy5ObS5pKHMsVy5UdyhudWxsKSkKQy5ObS5pKHMsVy5CbCgpKQokLmx0PXIKZD1y
+fWVsc2UgZD1zfXM9JC5FVQppZihzPT1udWxsKXtzPW5ldyBXLktvKGQpCiQuRVU9cwpjPXN9ZWxzZXtz
+LmE9ZApjPXN9fWVsc2UgaWYoZCE9bnVsbCl0aHJvdyBILmIoUC54WSgidmFsaWRhdG9yIGNhbiBvbmx5
+IGJlIHBhc3NlZCBpZiB0cmVlU2FuaXRpemVyIGlzIG51bGwiKSkKaWYoJC54bz09bnVsbCl7cz1kb2N1
+bWVudApyPXMuaW1wbGVtZW50YXRpb24Kci50b1N0cmluZwpyPUMubUguRGMociwiIikKJC54bz1yCiQu
+Qk89ci5jcmVhdGVSYW5nZSgpCnI9JC54by5jcmVhdGVFbGVtZW50KCJiYXNlIikKdC5jUi5hKHIpCnM9
+cy5iYXNlVVJJCnMudG9TdHJpbmcKci5ocmVmPXMKJC54by5oZWFkLmFwcGVuZENoaWxkKHIpfXM9JC54
+bwppZihzLmJvZHk9PW51bGwpe3I9cy5jcmVhdGVFbGVtZW50KCJib2R5IikKQy5CWi5zR1Mocyx0LnAu
+YShyKSl9cz0kLnhvCmlmKHQucC5iKGEpKXtzPXMuYm9keQpzLnRvU3RyaW5nCnE9c31lbHNle3MudG9T
+dHJpbmcKcT1zLmNyZWF0ZUVsZW1lbnQoYS50YWdOYW1lKQokLnhvLmJvZHkuYXBwZW5kQ2hpbGQocSl9
+aWYoImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnByb3RvdHlwZSYmIUMu
+Tm0udGcoQy5TcSxhLnRhZ05hbWUpKXskLkJPLnNlbGVjdE5vZGVDb250ZW50cyhxKQpzPSQuQk8Kcy50
+b1N0cmluZwpwPXMuY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50KGI9PW51bGw/Im51bGwiOmIpfWVsc2V7
+Si53ZihxLGIpCnA9JC54by5jcmVhdGVEb2N1bWVudEZyYWdtZW50KCkKZm9yKDtzPXEuZmlyc3RDaGls
+ZCxzIT1udWxsOylwLmFwcGVuZENoaWxkKHMpfWlmKHEhPT0kLnhvLmJvZHkpSi5MdChxKQpjLlBuKHAp
+CmRvY3VtZW50LmFkb3B0Tm9kZShwKQpyZXR1cm4gcH0sCkFIOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4g
+dGhpcy5yNihhLGIsYyxudWxsKX0sCnNoZjpmdW5jdGlvbihhLGIpe3RoaXMuWUMoYSxiKX0sCnBrOmZ1
+bmN0aW9uKGEsYixjKXt0aGlzLnNhNChhLG51bGwpCmEuYXBwZW5kQ2hpbGQodGhpcy5yNihhLGIsbnVs
+bCxjKSl9LApZQzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLnBrKGEsYixudWxsKX0sCnNSTjpmdW5j
+dGlvbihhLGIpe2EuaW5uZXJIVE1MPWJ9LApnbnM6ZnVuY3Rpb24oYSl7cmV0dXJuIGEudGFnTmFtZX0s
+CmdWbDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFcuZXUoYSwiY2xpY2siLCExLHQuayl9LAokaWN2OjF9
+ClcuQ3YucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuaC5iKHQuQS5hKGEpKX0sCiRT
+OjI1fQpXLmVhLnByb3RvdHlwZT17JGllYToxfQpXLkQwLnByb3RvdHlwZT17Ck9uOmZ1bmN0aW9uKGEs
+YixjLGQpe3QuYncuYShjKQppZihjIT1udWxsKXRoaXMudihhLGIsYyxkKX0sCkI6ZnVuY3Rpb24oYSxi
+LGMpe3JldHVybiB0aGlzLk9uKGEsYixjLG51bGwpfSwKdjpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4g
+YS5hZGRFdmVudExpc3RlbmVyKGIsSC50Uih0LmJ3LmEoYyksMSksZCl9LAokaUQwOjF9ClcuaEgucHJv
+dG90eXBlPXskaWhIOjF9ClcuaDQucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVu
+Z3RofX0KVy5ici5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLlZi
+LnByb3RvdHlwZT17CnNHUzpmdW5jdGlvbihhLGIpe2EuYm9keT1ifX0KVy5mSi5wcm90b3R5cGU9ewpl
+bzpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gYS5vcGVuKGIsYywhMCl9LAokaWZKOjF9Clcud2EucHJv
+dG90eXBlPXt9ClcuU2cucHJvdG90eXBlPXskaVNnOjF9ClcudzcucHJvdG90eXBlPXsKZ0RyOmZ1bmN0
+aW9uKGEpe2lmKCJvcmlnaW4iIGluIGEpcmV0dXJuIGEub3JpZ2luCnJldHVybiBILkVqKGEucHJvdG9j
+b2wpKyIvLyIrSC5FaihhLmhvc3QpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfSwKJGl3
+NzoxfQpXLkFqLnByb3RvdHlwZT17JGlBajoxfQpXLmU3LnByb3RvdHlwZT17CmdyODpmdW5jdGlvbihh
+KXt2YXIgcz10aGlzLmEscj1zLmNoaWxkTm9kZXMubGVuZ3RoCmlmKHI9PT0wKXRocm93IEguYihQLlBW
+KCJObyBlbGVtZW50cyIpKQppZihyPjEpdGhyb3cgSC5iKFAuUFYoIk1vcmUgdGhhbiBvbmUgZWxlbWVu
+dCIpKQpzPXMuZmlyc3RDaGlsZApzLnRvU3RyaW5nCnJldHVybiBzfSwKRlY6ZnVuY3Rpb24oYSxiKXt2
+YXIgcyxyLHEscCxvCnQuZWguYShiKQppZihiIGluc3RhbmNlb2YgVy5lNyl7cz1iLmEKcj10aGlzLmEK
+aWYocyE9PXIpZm9yKHE9cy5jaGlsZE5vZGVzLmxlbmd0aCxwPTA7cDxxOysrcCl7bz1zLmZpcnN0Q2hp
+bGQKby50b1N0cmluZwpyLmFwcGVuZENoaWxkKG8pfXJldHVybn1mb3Iocz1iLmdtKGIpLHI9dGhpcy5h
+O3MuRigpOylyLmFwcGVuZENoaWxkKHMuZ2woKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscgp0
+LkEuYShjKQpzPXRoaXMuYQpyPXMuY2hpbGROb2RlcwppZihiPDB8fGI+PXIubGVuZ3RoKXJldHVybiBI
+Lk9IKHIsYikKcy5yZXBsYWNlQ2hpbGQoYyxyW2JdKX0sCmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
+YS5jaGlsZE5vZGVzCnJldHVybiBuZXcgVy5XOShzLHMubGVuZ3RoLEgueihzKS5DKCJXOTxHbS5FPiIp
+KX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2hpbGROb2Rlcy5sZW5ndGh9LApxOmZ1bmN0
+aW9uKGEsYil7dmFyIHMKSC51UChiKQpzPXRoaXMuYS5jaGlsZE5vZGVzCmlmKGI8MHx8Yj49cy5sZW5n
+dGgpcmV0dXJuIEguT0gocyxiKQpyZXR1cm4gc1tiXX19ClcudUgucHJvdG90eXBlPXsKd2c6ZnVuY3Rp
+b24oYSl7dmFyIHM9YS5wYXJlbnROb2RlCmlmKHMhPW51bGwpcy5yZW1vdmVDaGlsZChhKX0sCkQ0OmZ1
+bmN0aW9uKGEpe3ZhciBzCmZvcig7cz1hLmZpcnN0Q2hpbGQscyE9bnVsbDspYS5yZW1vdmVDaGlsZChz
+KX0sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9YS5ub2RlVmFsdWUKcmV0dXJuIHM9PW51bGw/dGhpcy5VKGEp
+OnN9LApzYTQ6ZnVuY3Rpb24oYSxiKXthLnRleHRDb250ZW50PWJ9LAptSzpmdW5jdGlvbihhLGIsYyl7
+cmV0dXJuIGEuaW5zZXJ0QmVmb3JlKGIsYyl9LAokaXVIOjF9ClcuQkgucHJvdG90eXBlPXsKZ0E6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYj4+PjAh
+PT1ifHxiPj1hLmxlbmd0aCl0aHJvdyBILmIoUC5DZihiLGEsbnVsbCxudWxsLG51bGwpKQpyZXR1cm4g
+YVtiXX0sClk1OmZ1bmN0aW9uKGEsYixjKXt0LkEuYShjKQp0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGFz
+c2lnbiBlbGVtZW50IG9mIGltbXV0YWJsZSBMaXN0LiIpKX0sCmd0SDpmdW5jdGlvbihhKXtpZihhLmxl
+bmd0aD4wKXJldHVybiBhWzBdCnRocm93IEguYihQLlBWKCJObyBlbGVtZW50cyIpKX0sCkU6ZnVuY3Rp
+b24oYSxiKXtpZihiPDB8fGI+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsYikKcmV0dXJuIGFbYl19LAok
+aWJROjEsCiRpWGo6MSwKJGljWDoxLAokaXpNOjF9ClcuU04ucHJvdG90eXBlPXt9ClcuZXcucHJvdG90
+eXBlPXskaWV3OjF9ClcubHAucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3Ro
+fX0KVy5UYi5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyCmlmKCJjcmVhdGVD
+b250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5wcm90b3R5cGUpcmV0dXJuIHRoaXMuRFco
+YSxiLGMsZCkKcz1XLlU5KCI8dGFibGU+IitILkVqKGIpKyI8L3RhYmxlPiIsYyxkKQpyPWRvY3VtZW50
+LmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpyLnRvU3RyaW5nCnMudG9TdHJpbmcKbmV3IFcuZTcociku
+RlYoMCxuZXcgVy5lNyhzKSkKcmV0dXJuIHJ9fQpXLkl2LnByb3RvdHlwZT17CnI2OmZ1bmN0aW9uKGEs
+YixjLGQpe3ZhciBzLHIscSxwCmlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5S
+YW5nZS5wcm90b3R5cGUpcmV0dXJuIHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApyPXMuY3JlYXRl
+RG9jdW1lbnRGcmFnbWVudCgpCnM9Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxlIiksYixjLGQp
+CnMudG9TdHJpbmcKcz1uZXcgVy5lNyhzKQpxPXMuZ3I4KHMpCnEudG9TdHJpbmcKcz1uZXcgVy5lNyhx
+KQpwPXMuZ3I4KHMpCnIudG9TdHJpbmcKcC50b1N0cmluZwpuZXcgVy5lNyhyKS5GVigwLG5ldyBXLmU3
+KHApKQpyZXR1cm4gcn19ClcuV1AucHJvdG90eXBlPXsKcjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMs
+cixxCmlmKCJjcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQiIGluIHdpbmRvdy5SYW5nZS5wcm90b3R5cGUp
+cmV0dXJuIHRoaXMuRFcoYSxiLGMsZCkKcz1kb2N1bWVudApyPXMuY3JlYXRlRG9jdW1lbnRGcmFnbWVu
+dCgpCnM9Qy5JZS5yNihzLmNyZWF0ZUVsZW1lbnQoInRhYmxlIiksYixjLGQpCnMudG9TdHJpbmcKcz1u
+ZXcgVy5lNyhzKQpxPXMuZ3I4KHMpCnIudG9TdHJpbmcKcS50b1N0cmluZwpuZXcgVy5lNyhyKS5GVigw
+LG5ldyBXLmU3KHEpKQpyZXR1cm4gcn19ClcueVkucHJvdG90eXBlPXsKcGs6ZnVuY3Rpb24oYSxiLGMp
+e3ZhciBzLHIKdGhpcy5zYTQoYSxudWxsKQpzPWEuY29udGVudApzLnRvU3RyaW5nCkouYlQocykKcj10
+aGlzLnI2KGEsYixudWxsLGMpCmEuY29udGVudC5hcHBlbmRDaGlsZChyKX0sCllDOmZ1bmN0aW9uKGEs
+Yil7cmV0dXJuIHRoaXMucGsoYSxiLG51bGwpfSwKJGl5WToxfQpXLnc2LnByb3RvdHlwZT17fQpXLks1
+LnByb3RvdHlwZT17ClBvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1XLlAxKGEub3BlbihiLGMpKQpyZXR1
+cm4gc30sCmdtVzpmdW5jdGlvbihhKXtyZXR1cm4gYS5sb2NhdGlvbn0sCnVzOmZ1bmN0aW9uKGEsYil7
+cmV0dXJuIGEuY29uZmlybShiKX0sCiRpSzU6MSwKJGl2NjoxfQpXLkNtLnByb3RvdHlwZT17JGlDbTox
+fQpXLkNRLnByb3RvdHlwZT17JGlDUToxfQpXLnc0LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFy
+IHMscj1hLmxlZnQKci50b1N0cmluZwpyPSJSZWN0YW5nbGUgKCIrSC5FaihyKSsiLCAiCnM9YS50b3AK
+cy50b1N0cmluZwpzPXIrSC5FaihzKSsiKSAiCnI9YS53aWR0aApyLnRvU3RyaW5nCnI9cytILkVqKHIp
+KyIgeCAiCnM9YS5oZWlnaHQKcy50b1N0cmluZwpyZXR1cm4gcitILkVqKHMpfSwKRE46ZnVuY3Rpb24o
+YSxiKXt2YXIgcyxyCmlmKGI9PW51bGwpcmV0dXJuITEKaWYodC5xLmIoYikpe3M9YS5sZWZ0CnMudG9T
+dHJpbmcKcj1iLmxlZnQKci50b1N0cmluZwppZihzPT09cil7cz1hLnRvcApzLnRvU3RyaW5nCnI9Yi50
+b3AKci50b1N0cmluZwppZihzPT09cil7cz1hLndpZHRoCnMudG9TdHJpbmcKcj1iLndpZHRoCnIudG9T
+dHJpbmcKaWYocz09PXIpe3M9YS5oZWlnaHQKcy50b1N0cmluZwpyPWIuaGVpZ2h0CnIudG9TdHJpbmcK
+cj1zPT09cgpzPXJ9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITF9ZWxzZSBzPSExCnJldHVybiBz
+fSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPWEubGVmdApwLnRvU3RyaW5nCnA9Qy5DRC5naU8o
+cCkKcz1hLnRvcApzLnRvU3RyaW5nCnM9Qy5DRC5naU8ocykKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1D
+LkNELmdpTyhyKQpxPWEuaGVpZ2h0CnEudG9TdHJpbmcKcmV0dXJuIFcuckUocCxzLHIsQy5DRC5naU8o
+cSkpfX0KVy5yaC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1
+bmN0aW9uKGEsYil7SC51UChiKQppZihiPj4+MCE9PWJ8fGI+PWEubGVuZ3RoKXRocm93IEguYihQLkNm
+KGIsYSxudWxsLG51bGwsbnVsbCkpCnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3QuQS5h
+KGMpCnRocm93IEguYihQLkw0KCJDYW5ub3QgYXNzaWduIGVsZW1lbnQgb2YgaW1tdXRhYmxlIExpc3Qu
+IikpfSwKRTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5ndGgpcmV0dXJuIEguT0goYSxiKQpy
+ZXR1cm4gYVtiXX0sCiRpYlE6MSwKJGlYajoxLAokaWNYOjEsCiRpek06MX0KVy5jZi5wcm90b3R5cGU9
+ewpLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbwp0LmVBLmEoYikKZm9yKHM9dGhpcy5ndmMoKSxy
+PXMubGVuZ3RoLHE9dGhpcy5hLHA9MDtwPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8KDAsSC5saykocyks
+KytwKXtvPXNbcF0KYi4kMihvLHEuZ2V0QXR0cmlidXRlKG8pKX19LApndmM6ZnVuY3Rpb24oKXt2YXIg
+cyxyLHEscCxvLG4sbT10aGlzLmEuYXR0cmlidXRlcwptLnRvU3RyaW5nCnM9SC5WTShbXSx0LnMpCmZv
+cihyPW0ubGVuZ3RoLHE9dC5oOSxwPTA7cDxyOysrcCl7aWYocD49bS5sZW5ndGgpcmV0dXJuIEguT0go
+bSxwKQpvPXEuYShtW3BdKQppZihvLm5hbWVzcGFjZVVSST09bnVsbCl7bj1vLm5hbWUKbi50b1N0cmlu
+ZwpDLk5tLmkocyxuKX19cmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCku
+bGVuZ3RoPT09MH19ClcuaTcucHJvdG90eXBlPXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vVCh0aGlz
+LmEuaGFzQXR0cmlidXRlKGEpKQpyZXR1cm4gc30sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5h
+LmdldEF0dHJpYnV0ZShILmgoYikpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuYS5zZXRBdHRyaWJ1
+dGUoYixjKX0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH19ClcuU3kucHJv
+dG90eXBlPXsKeDQ6ZnVuY3Rpb24oYSl7dmFyIHM9SC5vVCh0aGlzLmEuYS5oYXNBdHRyaWJ1dGUoImRh
+dGEtIit0aGlzLk9VKGEpKSkKcmV0dXJuIHN9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYS5h
+LmdldEF0dHJpYnV0ZSgiZGF0YS0iK3RoaXMuT1UoSC5oKGIpKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7
+dGhpcy5hLmEuc2V0QXR0cmlidXRlKCJkYXRhLSIrdGhpcy5PVShiKSxjKX0sCks6ZnVuY3Rpb24oYSxi
+KXt0aGlzLmEuSygwLG5ldyBXLktTKHRoaXMsdC5lQS5hKGIpKSl9LApndmM6ZnVuY3Rpb24oKXt2YXIg
+cz1ILlZNKFtdLHQucykKdGhpcy5hLksoMCxuZXcgVy5BMyh0aGlzLHMpKQpyZXR1cm4gc30sCmdBOmZ1
+bmN0aW9uKGEpe3JldHVybiB0aGlzLmd2YygpLmxlbmd0aH0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy5ndmMoKS5sZW5ndGg9PT0wfSwKeHE6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUguVk0oYS5zcGxp
+dCgiLSIpLHQucykKZm9yKHM9MTtzPHEubGVuZ3RoOysrcyl7cj1xW3NdCmlmKHIubGVuZ3RoPjApQy5O
+bS5ZNShxLHMsclswXS50b1VwcGVyQ2FzZSgpK0ouS1YociwxKSl9cmV0dXJuIEMuTm0uayhxLCIiKX0s
+Ck9VOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8KZm9yKHM9YS5sZW5ndGgscj0wLHE9IiI7cjxzOysr
+cil7cD1hW3JdCm89cC50b0xvd2VyQ2FzZSgpCnE9KHAhPT1vJiZyPjA/cSsiLSI6cSkrb31yZXR1cm4g
+cS5jaGFyQ29kZUF0KDApPT0wP3E6cX19ClcuS1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXtp
+ZihKLnJZKGEpLm4oYSwiZGF0YS0iKSl0aGlzLmIuJDIodGhpcy5hLnhxKEMueEIueW4oYSw1KSksYil9
+LAokUzoxNX0KVy5BMy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe2lmKEouclkoYSkubihhLCJk
+YXRhLSIpKUMuTm0uaSh0aGlzLmIsdGhpcy5hLnhxKEMueEIueW4oYSw1KSkpfSwKJFM6MTV9ClcuSTQu
+cHJvdG90eXBlPXsKRDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89UC5Mcyh0Lk4pCmZvcihzPXRoaXMu
+YS5jbGFzc05hbWUuc3BsaXQoIiAiKSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPUouVDAoc1txXSkK
+aWYocC5sZW5ndGghPT0wKW8uaSgwLHApfXJldHVybiBvfSwKWDpmdW5jdGlvbihhKXt0aGlzLmEuY2xh
+c3NOYW1lPXQuQy5hKGEpLmsoMCwiICIpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFz
+c0xpc3QubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2xhc3NMaXN0Lmxlbmd0
+aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3RoIT09MH0s
+ClYxOmZ1bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05hbWU9IiJ9LAp0ZzpmdW5jdGlvbihhLGIpe3ZhciBz
+PXRoaXMuYS5jbGFzc0xpc3QuY29udGFpbnMoYikKcmV0dXJuIHN9LAppOmZ1bmN0aW9uKGEsYil7dmFy
+IHMscgpILmgoYikKcz10aGlzLmEuY2xhc3NMaXN0CnI9cy5jb250YWlucyhiKQpzLmFkZChiKQpyZXR1
+cm4hcn0sClI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPXRo
+aXMuYS5jbGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMucmVtb3ZlKGIpCnE9cn1lbHNlIHE9ITEKcmV0
+dXJuIHF9LApGVjpmdW5jdGlvbihhLGIpe1cuVE4odGhpcy5hLHQuUS5hKGIpKX19ClcuRmsucHJvdG90
+eXBlPXt9ClcuUk8ucHJvdG90eXBlPXt9ClcuZXUucHJvdG90eXBlPXt9ClcueEMucHJvdG90eXBlPXt9
+Clcudk4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMSh0LkIuYShhKSl9
+LAokUzoyN30KVy5KUS5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhKXt2YXIgcwppZigkLm9yLmE9PT0w
+KXtmb3Iocz0wO3M8MjYyOysrcykkLm9yLlk1KDAsQy5jbVtzXSxXLnBTKCkpCmZvcihzPTA7czwxMjsr
+K3MpJC5vci5ZNSgwLEMuQklbc10sVy5WNCgpKX19LAppMDpmdW5jdGlvbihhKXtyZXR1cm4gJC5BTigp
+LnRnKDAsVy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9JC5vci5xKDAsSC5FaihXLnJT
+KGEpKSsiOjoiK2IpCmlmKHM9PW51bGwpcz0kLm9yLnEoMCwiKjo6IitiKQppZihzPT1udWxsKXJldHVy
+biExCnJldHVybiBILnk4KHMuJDQoYSxiLGMsdGhpcykpfSwKJGlrRjoxfQpXLkdtLnByb3RvdHlwZT17
+CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5XOShhLHRoaXMuZ0EoYSksSC56KGEpLkMoIlc5PEdt
+LkU+IikpfX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1cm4gQy5ObS5Wcih0aGlz
+LmEsbmV3IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBDLk5tLlZyKHRoaXMuYSxu
+ZXcgVy5FZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
+dHVybiB0LkUuYShhKS5pMCh0aGlzLmEpfSwKJFM6MTZ9ClcuRWcucHJvdG90eXBlPXsKJDE6ZnVuY3Rp
+b24oYSl7cmV0dXJuIHQuRS5hKGEpLkViKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjE2fQpXLm02
+LnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQp0aGlzLmEuRlYoMCxjKQpz
+PWIuZXYoMCxuZXcgVy5FbygpKQpyPWIuZXYoMCxuZXcgVy5XaygpKQp0aGlzLmIuRlYoMCxzKQpxPXRo
+aXMuYwpxLkZWKDAsQy54RCkKcS5GVigwLHIpfSwKaTA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS50
+ZygwLFcuclMoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMscj1XLnJTKGEpLHE9cy5j
+CmlmKHEudGcoMCxILkVqKHIpKyI6OiIrYikpcmV0dXJuIHMuZC5EdChjKQplbHNlIGlmKHEudGcoMCwi
+Kjo6IitiKSlyZXR1cm4gcy5kLkR0KGMpCmVsc2V7cT1zLmIKaWYocS50ZygwLEguRWoocikrIjo6Iiti
+KSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCxI
+LkVqKHIpKyI6OioiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6KiIpKXJldHVybiEwfXJldHVy
+biExfSwKJGlrRjoxfQpXLkVvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiFDLk5tLnRn
+KEMuQkksSC5oKGEpKX0sCiRTOjZ9ClcuV2sucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJu
+IEMuTm0udGcoQy5CSSxILmgoYSkpfSwKJFM6Nn0KVy5jdC5wcm90b3R5cGU9ewpFYjpmdW5jdGlvbihh
+LGIsYyl7aWYodGhpcy5qRihhLGIsYykpcmV0dXJuITAKaWYoYj09PSJ0ZW1wbGF0ZSImJmM9PT0iIily
+ZXR1cm4hMAppZihhLmdldEF0dHJpYnV0ZSgidGVtcGxhdGUiKT09PSIiKXJldHVybiB0aGlzLmUudGco
+MCxiKQpyZXR1cm4hMX19ClcuSUEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIlRFTVBM
+QVRFOjoiK0guRWooSC5oKGEpKX0sCiRTOjV9ClcuT3cucHJvdG90eXBlPXsKaTA6ZnVuY3Rpb24oYSl7
+dmFyIHMKaWYodC5ldy5iKGEpKXJldHVybiExCnM9dC5nNy5iKGEpCmlmKHMmJlcuclMoYSk9PT0iZm9y
+ZWlnbk9iamVjdCIpcmV0dXJuITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0sCkViOmZ1bmN0aW9uKGEs
+YixjKXtpZihiPT09ImlzInx8Qy54Qi5uKGIsIm9uIikpcmV0dXJuITEKcmV0dXJuIHRoaXMuaTAoYSl9
+LAokaWtGOjF9ClcuVzkucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLmMrMSxx
+PXMuYgppZihyPHEpe3Muc3AoSi54OShzLmEscikpCnMuYz1yCnJldHVybiEwfXMuc3AobnVsbCkKcy5j
+PXEKcmV0dXJuITF9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9LApzcDpmdW5jdGlvbihhKXt0
+aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpXLmRXLnByb3RvdHlwZT17JGlEMDox
+LCRpdjY6MX0KVy5tay5wcm90b3R5cGU9eyRpeTA6MX0KVy5Lby5wcm90b3R5cGU9ewpQbjpmdW5jdGlv
+bihhKXt2YXIgcz10aGlzLHI9bmV3IFcuZm0ocykKcy5iPSExCnIuJDIoYSxudWxsKQpmb3IoO3MuYjsp
+e3MuYj0hMQpyLiQyKGEsbnVsbCl9fSwKRVA6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmI9ITAKaWYo
+YiE9bnVsbD9iIT09YS5wYXJlbnROb2RlOnMpSi5MdChhKQplbHNlIGIucmVtb3ZlQ2hpbGQoYSl9LApJ
+NDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj0hMCxtPW51bGwsbD1udWxsCnRyeXttPUouaWco
+YSkKbD1tLmEuZ2V0QXR0cmlidXRlKCJpcyIpCnQuaC5hKGEpCnM9ZnVuY3Rpb24oYyl7aWYoIShjLmF0
+dHJpYnV0ZXMgaW5zdGFuY2VvZiBOYW1lZE5vZGVNYXApKXJldHVybiB0cnVlCmlmKGMuaWQ9PSdsYXN0
+Q2hpbGQnfHxjLm5hbWU9PSdsYXN0Q2hpbGQnfHxjLmlkPT0ncHJldmlvdXNTaWJsaW5nJ3x8Yy5uYW1l
+PT0ncHJldmlvdXNTaWJsaW5nJ3x8Yy5pZD09J2NoaWxkcmVuJ3x8Yy5uYW1lPT0nY2hpbGRyZW4nKXJl
+dHVybiB0cnVlCnZhciBrPWMuY2hpbGROb2RlcwppZihjLmxhc3RDaGlsZCYmYy5sYXN0Q2hpbGQhPT1r
+W2subGVuZ3RoLTFdKXJldHVybiB0cnVlCmlmKGMuY2hpbGRyZW4paWYoIShjLmNoaWxkcmVuIGluc3Rh
+bmNlb2YgSFRNTENvbGxlY3Rpb258fGMuY2hpbGRyZW4gaW5zdGFuY2VvZiBOb2RlTGlzdCkpcmV0dXJu
+IHRydWUKdmFyIGo9MAppZihjLmNoaWxkcmVuKWo9Yy5jaGlsZHJlbi5sZW5ndGgKZm9yKHZhciBpPTA7
+aTxqO2krKyl7dmFyIGg9Yy5jaGlsZHJlbltpXQppZihoLmlkPT0nYXR0cmlidXRlcyd8fGgubmFtZT09
+J2F0dHJpYnV0ZXMnfHxoLmlkPT0nbGFzdENoaWxkJ3x8aC5uYW1lPT0nbGFzdENoaWxkJ3x8aC5pZD09
+J3ByZXZpb3VzU2libGluZyd8fGgubmFtZT09J3ByZXZpb3VzU2libGluZyd8fGguaWQ9PSdjaGlsZHJl
+bid8fGgubmFtZT09J2NoaWxkcmVuJylyZXR1cm4gdHJ1ZX1yZXR1cm4gZmFsc2V9KGEpCm49SC5vVChz
+KT8hMDohKGEuYXR0cmlidXRlcyBpbnN0YW5jZW9mIE5hbWVkTm9kZU1hcCl9Y2F0Y2gocCl7SC5SdShw
+KX1yPSJlbGVtZW50IHVucHJpbnRhYmxlIgp0cnl7cj1KLmooYSl9Y2F0Y2gocCl7SC5SdShwKX10cnl7
+cT1XLnJTKGEpCnRoaXMua1IodC5oLmEoYSksYixuLHIscSx0LmYuYShtKSxILmsobCkpfWNhdGNoKHAp
+e2lmKEguUnUocCkgaW5zdGFuY2VvZiBQLnUpdGhyb3cgcAplbHNle3RoaXMuRVAoYSxiKQp3aW5kb3cK
+bz0iUmVtb3ZpbmcgY29ycnVwdGVkIGVsZW1lbnQgIitILkVqKHIpCmlmKHR5cGVvZiBjb25zb2xlIT0i
+dW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKG8pfX19LAprUjpmdW5jdGlvbihhLGIsYyxkLGUs
+ZixnKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzCmlmKGMpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3Zp
+bmcgZWxlbWVudCBkdWUgdG8gY29ycnVwdGVkIGF0dHJpYnV0ZXMgb24gPCIrZCsiPiIKaWYodHlwZW9m
+IGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0dXJufWlmKCFtLmEu
+aTAoYSkpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBlbGVtZW50IDwiK0gu
+RWooZSkrIj4gZnJvbSAiK0guRWooYikKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRv
+dy5jb25zb2xlLndhcm4ocykKcmV0dXJufWlmKGchPW51bGwpaWYoIW0uYS5FYihhLCJpcyIsZykpe20u
+RVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCB0eXBlIGV4dGVuc2lvbiA8IitILkVq
+KGUpKycgaXM9IicrZysnIj4nCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29u
+c29sZS53YXJuKHMpCnJldHVybn1zPWYuZ3ZjKCkKcj1ILlZNKHMuc2xpY2UoMCksSC50NihzKSkKZm9y
+KHE9Zi5ndmMoKS5sZW5ndGgtMSxzPWYuYTtxPj0wOy0tcSl7aWYocT49ci5sZW5ndGgpcmV0dXJuIEgu
+T0gocixxKQpwPXJbcV0Kbz1tLmEKbj1KLmNIKHApCkguaChwKQppZighby5FYihhLG4scy5nZXRBdHRy
+aWJ1dGUocCkpKXt3aW5kb3cKbz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBhdHRyaWJ1dGUgPCIrSC5Faihl
+KSsiICIrcCsnPSInK0guRWoocy5nZXRBdHRyaWJ1dGUocCkpKyciPicKaWYodHlwZW9mIGNvbnNvbGUh
+PSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4obykKcy5yZW1vdmVBdHRyaWJ1dGUocCl9fWlm
+KHQuYVcuYihhKSl7cz1hLmNvbnRlbnQKcy50b1N0cmluZwptLlBuKHMpfX0sCiRpb246MX0KVy5mbS5w
+cm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMuYQpzd2l0Y2go
+YS5ub2RlVHlwZSl7Y2FzZSAxOm0uSTQoYSxiKQpicmVhawpjYXNlIDg6Y2FzZSAxMTpjYXNlIDM6Y2Fz
+ZSA0OmJyZWFrCmRlZmF1bHQ6bS5FUChhLGIpfXM9YS5sYXN0Q2hpbGQKZm9yKHE9dC5BO251bGwhPXM7
+KXtyPW51bGwKdHJ5e3I9cy5wcmV2aW91c1NpYmxpbmcKaWYociE9bnVsbCl7cD1yLm5leHRTaWJsaW5n
+Cm89cwpvPXA9PW51bGw/byE9bnVsbDpwIT09bwpwPW99ZWxzZSBwPSExCmlmKHApe3A9UC5QVigiQ29y
+cnVwdCBIVE1MIikKdGhyb3cgSC5iKHApfX1jYXRjaChuKXtILlJ1KG4pCnA9cS5hKHMpCm0uYj0hMApv
+PXAucGFyZW50Tm9kZQpvPWE9PW51bGw/byE9bnVsbDphIT09bwppZihvKXtvPXAucGFyZW50Tm9kZQpp
+ZihvIT1udWxsKW8ucmVtb3ZlQ2hpbGQocCl9ZWxzZSBhLnJlbW92ZUNoaWxkKHApCnM9bnVsbApyPWEu
+bGFzdENoaWxkfWlmKHMhPW51bGwpdGhpcy4kMihzLGEpCnM9cn19LAokUzozMH0KVy5MZS5wcm90b3R5
+cGU9e30KVy5LNy5wcm90b3R5cGU9e30KVy5yQi5wcm90b3R5cGU9e30KVy5YVy5wcm90b3R5cGU9e30K
+Vy5vYS5wcm90b3R5cGU9e30KUC5pSi5wcm90b3R5cGU9ewpWSDpmdW5jdGlvbihhKXt2YXIgcyxyPXRo
+aXMuYSxxPXIubGVuZ3RoCmZvcihzPTA7czxxOysrcylpZihyW3NdPT09YSlyZXR1cm4gcwpDLk5tLmko
+cixhKQpDLk5tLmkodGhpcy5iLG51bGwpCnJldHVybiBxfSwKUHY6ZnVuY3Rpb24oYSl7dmFyIHMscixx
+LHA9dGhpcyxvPXt9CmlmKGE9PW51bGwpcmV0dXJuIGEKaWYoSC5sKGEpKXJldHVybiBhCmlmKHR5cGVv
+ZiBhPT0ibnVtYmVyIilyZXR1cm4gYQppZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJuIGEKaWYoYSBp
+bnN0YW5jZW9mIFAuaVApcmV0dXJuIG5ldyBEYXRlKGEuYSkKaWYodC5mdi5iKGEpKXRocm93IEguYihQ
+LlNZKCJzdHJ1Y3R1cmVkIGNsb25lIG9mIFJlZ0V4cCIpKQppZih0LmM4LmIoYSkpcmV0dXJuIGEKaWYo
+dC53LmIoYSkpcmV0dXJuIGEKaWYodC5JLmIoYSkpcmV0dXJuIGEKcz10LmRFLmIoYSl8fCExCmlmKHMp
+cmV0dXJuIGEKaWYodC5mLmIoYSkpe3I9cC5WSChhKQpzPXAuYgppZihyPj1zLmxlbmd0aClyZXR1cm4g
+SC5PSChzLHIpCnE9by5hPXNbcl0KaWYocSE9bnVsbClyZXR1cm4gcQpxPXt9Cm8uYT1xCkMuTm0uWTUo
+cyxyLHEpCmEuSygwLG5ldyBQLmpnKG8scCkpCnJldHVybiBvLmF9aWYodC5qLmIoYSkpe3I9cC5WSChh
+KQpvPXAuYgppZihyPj1vLmxlbmd0aClyZXR1cm4gSC5PSChvLHIpCnE9b1tyXQppZihxIT1udWxsKXJl
+dHVybiBxCnJldHVybiBwLmVrKGEscil9aWYodC5lSC5iKGEpKXtyPXAuVkgoYSkKcz1wLmIKaWYocj49
+cy5sZW5ndGgpcmV0dXJuIEguT0gocyxyKQpxPW8uYj1zW3JdCmlmKHEhPW51bGwpcmV0dXJuIHEKcT17
+fQpvLmI9cQpDLk5tLlk1KHMscixxKQpwLmltKGEsbmV3IFAuVGEobyxwKSkKcmV0dXJuIG8uYn10aHJv
+dyBILmIoUC5TWSgic3RydWN0dXJlZCBjbG9uZSBvZiBvdGhlciB0eXBlIikpfSwKZWs6ZnVuY3Rpb24o
+YSxiKXt2YXIgcyxyPUouVTYoYSkscT1yLmdBKGEpLHA9bmV3IEFycmF5KHEpCkMuTm0uWTUodGhpcy5i
+LGIscCkKZm9yKHM9MDtzPHE7KytzKUMuTm0uWTUocCxzLHRoaXMuUHYoci5xKGEscykpKQpyZXR1cm4g
+cH19ClAuamcucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuYVthXT10aGlzLmIuUHYo
+Yil9LAokUzozMX0KUC5UYS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS5iW2FdPXRo
+aXMuYi5QdihiKX0sCiRTOjE3fQpQLkJmLnByb3RvdHlwZT17CmltOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxLHAKdC5iOC5hKGIpCmZvcihzPU9iamVjdC5rZXlzKGEpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Ep
+e3A9c1txXQpiLiQyKHAsYVtwXSl9fX0KUC5Bcy5wcm90b3R5cGU9ewpWOmZ1bmN0aW9uKGEpe3ZhciBz
+CkguaChhKQpzPSQuaEcoKS5iCmlmKHR5cGVvZiBhIT0ic3RyaW5nIilILnYoSC50TChhKSkKaWYocy50
+ZXN0KGEpKXJldHVybiBhCnRocm93IEguYihQLkwzKGEsInZhbHVlIiwiTm90IGEgdmFsaWQgY2xhc3Mg
+dG9rZW4iKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5rKDAsIiAiKX0sCmdtOmZ1bmN0
+aW9uKGEpe3ZhciBzPXRoaXMuRCgpCnJldHVybiBQLnJqKHMscy5yLEguTGgocykuYyl9LApnbDA6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIHRoaXMuRCgpLmE9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlz
+LkQoKS5hIT09MH0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hfSwKdGc6ZnVuY3Rpb24o
+YSxiKXt0aGlzLlYoYikKcmV0dXJuIHRoaXMuRCgpLnRnKDAsYil9LAppOmZ1bmN0aW9uKGEsYil7dmFy
+IHMKSC5oKGIpCnRoaXMuVihiKQpzPXRoaXMuT1MobmV3IFAuR0UoYikpCnJldHVybiBILnk4KHM9PW51
+bGw/ITE6cyl9LApSOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZih0eXBlb2YgYiE9InN0cmluZyIpcmV0
+dXJuITEKdGhpcy5WKGIpCnM9dGhpcy5EKCkKcj1zLlIoMCxiKQp0aGlzLlgocykKcmV0dXJuIHJ9LApG
+VjpmdW5jdGlvbihhLGIpe3RoaXMuT1MobmV3IFAuTjcodGhpcyx0LlEuYShiKSkpfSwKZVI6ZnVuY3Rp
+b24oYSxiKXt2YXIgcz10aGlzLkQoKQpyZXR1cm4gSC5iSyhzLGIsSC5MaChzKS5DKCJsZi5FIikpfSwK
+RTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLkQoKS5FKDAsYil9LApWMTpmdW5jdGlvbihhKXt0aGlz
+Lk9TKG5ldyBQLnVRKCkpfSwKT1M6ZnVuY3Rpb24oYSl7dmFyIHMscgp0LmJVLmEoYSkKcz10aGlzLkQo
+KQpyPWEuJDEocykKdGhpcy5YKHMpCnJldHVybiByfX0KUC5HRS5wcm90b3R5cGU9ewokMTpmdW5jdGlv
+bihhKXtyZXR1cm4gdC5DLmEoYSkuaSgwLHRoaXMuYSl9LAokUzozM30KUC5ONy5wcm90b3R5cGU9ewok
+MTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIscj1ILnQ2KHMpCnJldHVybiB0LkMuYShhKS5GVigwLG5l
+dyBILmxKKHMsci5DKCJxVSgxKSIpLmEodGhpcy5hLmd1TSgpKSxyLkMoImxKPDEscVU+IikpKX0sCiRT
+OjE4fQpQLnVRLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuQy5hKGEpCmlmKGEuYT4wKXthLmI9
+YS5jPWEuZD1hLmU9YS5mPW51bGwKYS5hPTAKYS5TKCl9cmV0dXJuIG51bGx9LAokUzoxOH0KUC5oRi5w
+cm90b3R5cGU9eyRpaEY6MX0KUC5QQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Llku
+YShhKQpzPWZ1bmN0aW9uKGIsYyxkKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4gYihjLGQsdGhpcyxB
+cnJheS5wcm90b3R5cGUuc2xpY2UuYXBwbHkoYXJndW1lbnRzKSl9fShQLlI0LGEsITEpClAuRG0ocywk
+LncoKSxhKQpyZXR1cm4gc30sCiRTOjR9ClAubXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0
+dXJuIG5ldyB0aGlzLmEoYSl9LAokUzo0fQpQLlFTLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBuZXcgUC5yNyhhKX0sCiRTOjM1fQpQLm5wLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBuZXcgUC5UeihhLHQuYW0pfSwKJFM6NDV9ClAuVXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
+YSl7cmV0dXJuIG5ldyBQLkU0KGEpfSwKJFM6Mzd9ClAuRTQucHJvdG90eXBlPXsKcTpmdW5jdGlvbihh
+LGIpe2lmKHR5cGVvZiBiIT0ic3RyaW5nIiYmdHlwZW9mIGIhPSJudW1iZXIiKXRocm93IEguYihQLnhZ
+KCJwcm9wZXJ0eSBpcyBub3QgYSBTdHJpbmcgb3IgbnVtIikpCnJldHVybiBQLmRVKHRoaXMuYVtiXSl9
+LApZNTpmdW5jdGlvbihhLGIsYyl7aWYodHlwZW9mIGIhPSJzdHJpbmciJiZ0eXBlb2YgYiE9Im51bWJl
+ciIpdGhyb3cgSC5iKFAueFkoInByb3BlcnR5IGlzIG5vdCBhIFN0cmluZyBvciBudW0iKSkKdGhpcy5h
+W2JdPVAud1koYyl9LApETjpmdW5jdGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKcmV0dXJuIGIg
+aW5zdGFuY2VvZiBQLkU0JiZ0aGlzLmE9PT1iLmF9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIKdHJ5e3M9
+U3RyaW5nKHRoaXMuYSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKQpzPXRoaXMueGIoMCkKcmV0dXJu
+IHN9fSwKVjc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuYQppZihiPT1udWxsKXM9bnVsbAplbHNl
+e3M9SC50NihiKQpzPVAuQ0gobmV3IEgubEooYixzLkMoIkAoMSkiKS5hKFAuaUcoKSkscy5DKCJsSjwx
+LEA+IikpLCEwLHQueil9cmV0dXJuIFAuZFUoclthXS5hcHBseShyLHMpKX0sCmdpTzpmdW5jdGlvbihh
+KXtyZXR1cm4gMH19ClAucjcucHJvdG90eXBlPXt9ClAuVHoucHJvdG90eXBlPXsKY1A6ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcyxyPWE8MHx8YT49cy5nQShzKQppZihyKXRocm93IEguYihQLlRFKGEsMCxzLmdB
+KHMpLG51bGwsbnVsbCkpfSwKcTpmdW5jdGlvbihhLGIpe2lmKEgub2soYikpdGhpcy5jUChiKQpyZXR1
+cm4gdGhpcy4kdGkuYy5hKHRoaXMuVXIoMCxiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5jUChi
+KQp0aGlzLmJoKDAsYixjKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5sZW5ndGgKaWYodHlw
+ZW9mIHM9PT0ibnVtYmVyIiYmcz4+PjA9PT1zKXJldHVybiBzCnRocm93IEguYihQLlBWKCJCYWQgSnNB
+cnJheSBsZW5ndGgiKSl9LAokaWJROjEsCiRpY1g6MSwKJGl6TToxfQpQLmNvLnByb3RvdHlwZT17Clk1
+OmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gdGhpcy5lNCgwLGIsYyl9fQpQLm5kLnByb3RvdHlwZT17JGlu
+ZDoxfQpQLktlLnByb3RvdHlwZT17CkQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMuYS5nZXRB
+dHRyaWJ1dGUoImNsYXNzIiksbj1QLkxzKHQuTikKaWYobz09bnVsbClyZXR1cm4gbgpmb3Iocz1vLnNw
+bGl0KCIgIikscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1KLlQwKHNbcV0pCmlmKHAubGVuZ3RoIT09
+MCluLmkoMCxwKX1yZXR1cm4gbn0sClg6ZnVuY3Rpb24oYSl7dGhpcy5hLnNldEF0dHJpYnV0ZSgiY2xh
+c3MiLGEuaygwLCIgIikpfX0KUC5oaS5wcm90b3R5cGU9ewpnUDpmdW5jdGlvbihhKXtyZXR1cm4gbmV3
+IFAuS2UoYSl9LApzaGY6ZnVuY3Rpb24oYSxiKXt0aGlzLllDKGEsYil9LApyNjpmdW5jdGlvbihhLGIs
+YyxkKXt2YXIgcyxyLHEscCxvLG4KaWYoZD09bnVsbCl7cz1ILlZNKFtdLHQudikKZD1uZXcgVy52RChz
+KQpDLk5tLmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJsKCkpCkMuTm0uaShzLG5ldyBXLk93KCkp
+fWM9bmV3IFcuS28oZCkKcj0nPHN2ZyB2ZXJzaW9uPSIxLjEiPicrSC5FaihiKSsiPC9zdmc+IgpzPWRv
+Y3VtZW50CnE9cy5ib2R5CnEudG9TdHJpbmcKcD1DLlJZLkFIKHEscixjKQpvPXMuY3JlYXRlRG9jdW1l
+bnRGcmFnbWVudCgpCnAudG9TdHJpbmcKcz1uZXcgVy5lNyhwKQpuPXMuZ3I4KHMpCmZvcig7cz1uLmZp
+cnN0Q2hpbGQscyE9bnVsbDspby5hcHBlbmRDaGlsZChzKQpyZXR1cm4gb30sCm56OmZ1bmN0aW9uKGEs
+YixjLGQsZSl7dGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBpbnZva2UgaW5zZXJ0QWRqYWNlbnRIdG1sIG9u
+IFNWRy4iKSl9LApnVmw6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLmV1KGEsImNsaWNrIiwhMSx0Lmsp
+fSwKJGloaToxfQpVLmQyLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlz
+LG49dC5YLG09dC5fLGw9UC5GbChuLG0pLGs9by5hCmlmKGshPW51bGwpe3M9SC5WTShbXSx0LkcpCmZv
+cihyPWsubGVuZ3RoLHE9MDtxPGsubGVuZ3RoO2subGVuZ3RoPT09cnx8KDAsSC5saykoayksKytxKXtw
+PWtbcV0Kcy5wdXNoKFAuRUYoWyJkZXNjcmlwdGlvbiIscC5hLCJocmVmIixwLmJdLG4sbSkpfWwuWTUo
+MCwiZWRpdHMiLHMpfWwuWTUoMCwiZXhwbGFuYXRpb24iLG8uYikKbC5ZNSgwLCJsaW5lIixvLmMpCmwu
+WTUoMCwiZGlzcGxheVBhdGgiLG8uZCkKbC5ZNSgwLCJ1cmlQYXRoIixvLmUpCm49by5mCmlmKG4hPW51
+bGwpe209SC5WTShbXSx0LkcpCmZvcihrPW4ubGVuZ3RoLHE9MDtxPG4ubGVuZ3RoO24ubGVuZ3RoPT09
+a3x8KDAsSC5saykobiksKytxKW0ucHVzaChuW3FdLkx0KCkpCmwuWTUoMCwidHJhY2VzIixtKX1yZXR1
+cm4gbH19ClUuU2UucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbImRlc2NyaXB0
+aW9uIix0aGlzLmEsImhyZWYiLHRoaXMuYl0sdC5YLHQuXyl9fQpVLk1sLnByb3RvdHlwZT17Ckx0OmZ1
+bmN0aW9uKCl7cmV0dXJuIFAuRUYoWyJocmVmIix0aGlzLmEsImxpbmUiLHRoaXMuYiwicGF0aCIsdGhp
+cy5jXSx0LlgsdC5fKX19ClUueUQucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD1I
+LlZNKFtdLHQuRykKZm9yKHM9dGhpcy5iLHI9cy5sZW5ndGgscT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9
+PT1yfHwoMCxILmxrKShzKSwrK3EpcC5wdXNoKHNbcV0uTHQoKSkKcmV0dXJuIFAuRUYoWyJkZXNjcmlw
+dGlvbiIsdGhpcy5hLCJlbnRyaWVzIixwXSx0LlgsdC5fKX19ClUud2IucHJvdG90eXBlPXsKTHQ6ZnVu
+Y3Rpb24oKXt2YXIgcyxyLHEscD10aGlzLG89UC5GbCh0LlgsdC5fKQpvLlk1KDAsImRlc2NyaXB0aW9u
+IixwLmEpCnM9cC5iCmlmKHMhPW51bGwpby5ZNSgwLCJmdW5jdGlvbiIscykKcz1wLmMKaWYocyE9bnVs
+bClvLlk1KDAsImxpbmsiLHMuTHQoKSkKcz1wLmQKaWYocy5sZW5ndGghPT0wKXtyPUgudDYocykKcT1y
+LkMoImxKPDEsWjA8cVUqLE1oKj4qPiIpCm8uWTUoMCwiaGludEFjdGlvbnMiLFAuWTEobmV3IEgubEoo
+cyxyLkMoIlowPHFVKixNaCo+KigxKSIpLmEobmV3IFUuYjAoKSkscSksITAscS5DKCJhTC5FIikpKX1y
+ZXR1cm4gb319ClUuYU4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIFIubnoodC50LmEo
+YSkpfSwKJFM6Mzh9ClUuYjAucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuYVguYShh
+KS5MdCgpfSwKJFM6Mzl9CkIuajgucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihb
+ImxpbmUiLHRoaXMuYSwiZXhwbGFuYXRpb24iLHRoaXMuYiwib2Zmc2V0Iix0aGlzLmNdLHQuWCx0Ll8p
+fX0KQi5xcC5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcyxr
+PXQuWCxqPVAuRmwoayx0LmRwKQpmb3Iocz1sLmQscz1zLmdQdShzKSxzPXMuZ20ocykscj10Ll8scT10
+Lkc7cy5GKCk7KXtwPXMuZ2woKQpvPXAuYQpuPUguVk0oW10scSkKZm9yKHA9Si5JVChwLmIpO3AuRigp
+Oyl7bT1wLmdsKCkKbi5wdXNoKFAuRUYoWyJsaW5lIixtLmEsImV4cGxhbmF0aW9uIixtLmIsIm9mZnNl
+dCIsbS5jXSxrLHIpKX1qLlk1KDAsbyxuKX1yZXR1cm4gUC5FRihbInJlZ2lvbnMiLGwuYSwibmF2aWdh
+dGlvbkNvbnRlbnQiLGwuYiwic291cmNlQ29kZSIsbC5jLCJlZGl0cyIsal0sayxyKX19ClQubVEucHJv
+dG90eXBlPXt9CkwuZS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbQp0
+LmFMLmEoYSkKcz13aW5kb3cubG9jYXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlvbi5o
+cmVmKQpxPUwuYUsod2luZG93LmxvY2F0aW9uLmhyZWYpCkwuR2UoKQppZihzIT09Ii8iJiZzIT09Si5U
+MChkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucm9vdCIpLnRleHRDb250ZW50KSlMLkc3KHMscixxLCEw
+LG5ldyBMLlZXKHMscixxKSkKcD1kb2N1bWVudApvPUoucUYocC5xdWVyeVNlbGVjdG9yKCIuYXBwbHkt
+bWlncmF0aW9uIikpCm49by4kdGkKbT1uLkMoIn4oMSk/IikuYShuZXcgTC5vWigpKQp0LlouYShudWxs
+KQpXLkpFKG8uYSxvLmIsbSwhMSxuLmMpCm49Si5xRihwLnF1ZXJ5U2VsZWN0b3IoIi5yZXJ1bi1taWdy
+YXRpb24iKSkKbT1uLiR0aQpXLkpFKG4uYSxuLmIsbS5DKCJ+KDEpPyIpLmEobmV3IEwuSGkoKSksITEs
+bS5jKQptPUoucUYocC5xdWVyeVNlbGVjdG9yKCIucmVwb3J0LXByb2JsZW0iKSkKbj1tLiR0aQpXLkpF
+KG0uYSxtLmIsbi5DKCJ+KDEpPyIpLmEobmV3IEwuQlQoKSksITEsbi5jKQpwPUoucUYocC5xdWVyeVNl
+bGVjdG9yKCIucG9wdXAtcGFuZSAuY2xvc2UiKSkKbj1wLiR0aQpXLkpFKHAuYSxwLmIsbi5DKCJ+KDEp
+PyIpLmEobmV3IEwuUFkoKSksITEsbi5jKQpuPUoucUYoJC5jMCgpKQpwPW4uJHRpClcuSkUobi5hLG4u
+YixwLkMoIn4oMSk/IikuYShuZXcgTC51OCgpKSwhMSxwLmMpfSwKJFM6MTl9CkwuVlcucHJvdG90eXBl
+PXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjJ9Ckwub1oucHJv
+dG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbwp0Lk8uYShhKQppZihILm9UKEMub2wu
+dXMod2luZG93LCJUaGlzIHdpbGwgYXBwbHkgdGhlIGNoYW5nZXMgeW91J3ZlIHByZXZpZXdlZCB0byB5
+b3VyIHdvcmtpbmcgZGlyZWN0b3J5LiBJdCBpcyByZWNvbW1lbmRlZCB5b3UgY29tbWl0IGFueSBjaGFu
+Z2VzIHlvdSBtYWRlIGJlZm9yZSBkb2luZyB0aGlzLiIpKSl7cz1ILlZNKFtdLHQuRykKZm9yKHI9JC5J
+UixxPXIubGVuZ3RoLHA9MDtwPHIubGVuZ3RoO3IubGVuZ3RoPT09cXx8KDAsSC5saykociksKytwKXMu
+cHVzaChyW3BdLkx0KCkpCnM9TC50eSgiL2FwcGx5LW1pZ3JhdGlvbiIsUC5FRihbIm5hdmlnYXRpb25U
+cmVlIixzXSx0LlgsdC5kcCkpLlc3KG5ldyBMLmpyKCksdC5QKQpvPW5ldyBMLnFsKCkKdC5iNy5hKG51
+bGwpCnI9cy4kdGkKcT0kLlgzCmlmKHEhPT1DLk5VKW89UC5WSChvLHEpCnMueGYobmV3IFAuRmUobmV3
+IFAudnMocSxyKSwyLG51bGwsbyxyLkMoIkA8MT4iKS5LcShyLmMpLkMoIkZlPDEsMj4iKSkpfX0sCiRT
+OjF9CkwuanIucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC50LmEoYSkKcz1kb2N1bWVu
+dC5ib2R5CnMuY2xhc3NMaXN0LnJlbW92ZSgicHJvcG9zZWQiKQpzLmNsYXNzTGlzdC5hZGQoImFwcGxp
+ZWQiKX0sCiRTOjQyfQpMLnFsLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7TC5DMigiQ291bGQg
+bm90IGFwcGx5IG1pZ3JhdGlvbiIsYSxiKX0sCiRDOiIkMiIsCiRSOjIsCiRTOjE3fQpMLkhpLnByb3Rv
+dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnhuKHQuTy5hKGEpKX0sCnhuOmZ1bmN0aW9u
+KGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuLG0sbCxrLGoKdmFyICRhc3luYyQkMT1Q
+Lmx6KGZ1bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9YwpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2Fz
+ZSAwOnE9Mwpkb2N1bWVudC5ib2R5LmNsYXNzTGlzdC5hZGQoInJlcnVubmluZyIpCnM9NgpyZXR1cm4g
+UC5qUShMLnR5KCIvcmVydW4tbWlncmF0aW9uIixudWxsKSwkYXN5bmMkJDEpCmNhc2UgNjpuPWMKaWYo
+SC5vVChILnk4KEoueDkobiwic3VjY2VzcyIpKSkpd2luZG93LmxvY2F0aW9uLnJlbG9hZCgpCmVsc2Ug
+TC5LMCh0LmVFLmEoSi54OShuLCJlcnJvcnMiKSkpCm8ucHVzaCg1KQpzPTQKYnJlYWsKY2FzZSAzOnE9
+MgpqPXAKbT1ILlJ1KGopCmw9SC50cyhqKQpMLkMyKCJGYWlsZWQgdG8gcmVydW4gbWlncmF0aW9uIixt
+LGwpCm8ucHVzaCg1KQpzPTQKYnJlYWsKY2FzZSAyOm89WzFdCmNhc2UgNDpxPTEKZG9jdW1lbnQuYm9k
+eS5jbGFzc0xpc3QucmVtb3ZlKCJyZXJ1bm5pbmciKQpzPW8ucG9wKCkKYnJlYWsKY2FzZSA1OnJldHVy
+biBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5j
+JCQxLHIpfSwKJFM6MjB9CkwuQlQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dC5PLmEoYSkKQy5v
+bC5Qbyh3aW5kb3csUC5YZCgiaHR0cHMiLCJnaXRodWIuY29tIiwiZGFydC1sYW5nL3Nkay9pc3N1ZXMv
+bmV3IixQLkVGKFsidGl0bGUiLCJDdXN0b21lci1yZXBvcnRlZCBpc3N1ZSB3aXRoIE5OQkQgbWlncmF0
+aW9uIHRvb2wiLCJsYWJlbHMiLHUuZCwiYm9keSIsIiMjIyMgU3RlcHMgdG8gcmVwcm9kdWNlXG5cbiMj
+IyMgV2hhdCBkaWQgeW91IGV4cGVjdCB0byBoYXBwZW4/XG5cbiMjIyMgV2hhdCBhY3R1YWxseSBoYXBw
+ZW5lZD9cblxuX1NjcmVlbnNob3RzIGFyZSBhcHByZWNpYXRlZF9cblxuKipEYXJ0IFNESyB2ZXJzaW9u
+Kio6ICIrSC5Faihkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic2RrLXZlcnNpb24iKS50ZXh0Q29udGVu
+dCkrIlxuXG5UaGFua3MgZm9yIGZpbGluZyFcbiJdLHQuWCx0LnopKS5nbkQoKSwicmVwb3J0LXByb2Js
+ZW0iKX0sCiRTOjF9CkwuUFkucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC5PLmEoYSkK
+cz1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIpLnN0eWxlCnMuZGlzcGxheT0ibm9u
+ZSIKcmV0dXJuIm5vbmUifSwKJFM6NDR9CkwudTgucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFy
+IHMscixxLHAKdC5PLmEoYSkKcz0kLkQ5KCkuaW5uZXJUZXh0CnI9dC5nLmEoZG9jdW1lbnQucXVlcnlT
+ZWxlY3RvcignLm5hdi1wYW5lbCBbZGF0YS1uYW1lKj0iJytILkVqKHMpKyciXScpLnBhcmVudE5vZGUp
+CnE9ci5xdWVyeVNlbGVjdG9yKCIuc3RhdHVzLWljb24iKQpwPUwubUgoJC5JUixzKQppZihwIGluc3Rh
+bmNlb2YgTC5jRCYmSC5vVChwLngpKXtMLk90KHApCkwueG4ocSxwKQpMLkFSKHIscCl9fSwKJFM6MX0K
+TC5MLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscQp0LmFMLmEoYSkKcz13aW5kb3cu
+bG9jYXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlvbi5ocmVmKQpxPUwuYUsod2luZG93
+LmxvY2F0aW9uLmhyZWYpCmlmKHMubGVuZ3RoPjEpTC5HNyhzLHIscSwhMSxudWxsKQplbHNle0wuQkUo
+cyxCLndSKCksITApCkwuQlgoIiZuYnNwOyIsbnVsbCl9fSwKJFM6MTl9CkwuV3gucHJvdG90eXBlPXsK
+JDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9ImNvbGxhcHNlZCIKdC5PLmEoYSkKcz10aGlzLmEKcj1K
+LllFKHMpCnE9dGhpcy5iCmlmKCFyLmdQKHMpLnRnKDAscCkpe3IuZ1AocykuaSgwLHApCkouZFIocSku
+aSgwLHApfWVsc2V7ci5nUChzKS5SKDAscCkKSi5kUihxKS5SKDAscCl9fSwKJFM6MX0KTC5BTy5wcm90
+b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcz1KLnFGKHQuZy5hKGEpKSxyPXMuJHRpLHE9ci5DKCJ+
+KDEpPyIpLmEobmV3IEwuZE4odGhpcy5hKSkKdC5aLmEobnVsbCkKVy5KRShzLmEscy5iLHEsITEsci5j
+KX0sCiRTOjN9CkwuZE4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEwudDIodC5PLmEo
+YSksdGhpcy5hKX0sCiRTOjd9CkwuSG8ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixx
+CnQuZy5hKGEpCnM9Si5xRihhKQpyPXMuJHRpCnE9ci5DKCJ+KDEpPyIpLmEobmV3IEwueHooYSx0aGlz
+LmEpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIscSwhMSxyLmMpfSwKJFM6M30KTC54ei5wcm90b3R5
+cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPXRoaXMuYQpMLmhYKHRoaXMuYixQLlFB
+KHMuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcocykpLk9VKCJvZmZzZXQiKSks
+bnVsbCksUC5RQShzLmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5PVSgi
+bGluZSIpKSxudWxsKSl9LAokUzoxfQpMLklDLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBz
+PUoucUYodC5nLmEoYSkpLHI9cy4kdGkKci5DKCJ+KDEpPyIpLmEoTC5pUygpKQp0LlouYShudWxsKQpX
+LkpFKHMuYSxzLmIsTC5pUygpLCExLHIuYyl9LAokUzozfQpMLmZDLnByb3RvdHlwZT17CiQxOmZ1bmN0
+aW9uKGEpe3QuZVEuYShhKQp0aGlzLmEuYU0oMCx0aGlzLmIpfSwKJFM6NDd9CkwublQucHJvdG90eXBl
+PXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjJ9CkwuTlkucHJv
+dG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSxudWxsLG51bGwpfSwKJFM6Mn0KTC51ZS5w
+cm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0LmF3LmEoYSkKcmV0dXJuIEguRWooYS5xKDAsInNldmVy
+aXR5IikpKyIgLSAiK0guRWooYS5xKDAsIm1lc3NhZ2UiKSkrIiBhdCAiK0guRWooYS5xKDAsImxvY2F0
+aW9uIikpKyIgLSAoIitILkVqKGEucSgwLCJjb2RlIikpKyIpIn0sCiRTOjQ4fQpMLmVYLnByb3RvdHlw
+ZT17CiQxOmZ1bmN0aW9uKGEpe3QuZy5hKGEpCiQuekIoKS50b1N0cmluZwp0LmRILmEoJC5vdygpLnEo
+MCwiaGxqcyIpKS5WNygiaGlnaGxpZ2h0QmxvY2siLFthXSl9LAokUzozfQpMLkVFLnByb3RvdHlwZT17
+CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdC5PLmEoYSkucHJldmVudERlZmF1bHQoKQpzPXRoaXMuYQpy
+PXRoaXMuYgpMLmFmKHdpbmRvdy5sb2NhdGlvbi5wYXRobmFtZSxzLHIsITAsbmV3IEwuUUwocyxyKSkK
+TC5oWCh0aGlzLmMscyxyKX0sCiRTOjF9CkwuUUwucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtMLkZy
+KHdpbmRvdy5sb2NhdGlvbi5wYXRobmFtZSx0aGlzLmEsdGhpcy5iKX0sCiRTOjJ9CkwuVlMucHJvdG90
+eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscj0ic2VsZWN0ZWQtZmlsZSIKdC5nLmEoYSkKYS50b1N0
+cmluZwpzPUouWUUoYSkKaWYoYS5nZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhh
+KSkuT1UoIm5hbWUiKSk9PT10aGlzLmEuYSlzLmdQKGEpLmkoMCxyKQplbHNlIHMuZ1AoYSkuUigwLHIp
+fSwKJFM6M30KTC5URC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyCnQuTy5hKGEpCnM9
+dGhpcy5hCnN3aXRjaChzLmdMKCkpe2Nhc2UgQy5jdzpicmVhawpjYXNlIEMuV0Q6cy5uRygpCmJyZWFr
+CmNhc2UgQy5YajpzLmMyKCkKYnJlYWsKY2FzZSBDLmRjOnMuYzIoKQpicmVha31yPXRoaXMuYgpMLmhs
+KHIscykKTC54bih0aGlzLmMscykKTC5BUihyLHMpfSwKJFM6MX0KTC5JZi5wcm90b3R5cGU9ewokMTpm
+dW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPXRoaXMuYQpMLk90KHMpCkwueG4odGhpcy5iLHMpCkwu
+QVIodGhpcy5jLHMpfSwKJFM6MX0KTC50Qi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4g
+TC50Mih0Lk8uYShhKSwhMCl9LAokUzo3fQpMLm0yLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
+dHVybiB0aGlzLlJJKHQuTy5hKGEpKX0sClJJOmZ1bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQuUCks
+cT0xLHAsbz1bXSxuPXRoaXMsbSxsLGssaixpLGgsZyxmCnZhciAkYXN5bmMkJDE9UC5seihmdW5jdGlv
+bihiLGMpe2lmKGI9PT0xKXtwPWMKcz1xfXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nhc2UgMDpxPTMKaT1k
+b2N1bWVudAptPUMuQ0QuelEoaS5xdWVyeVNlbGVjdG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkKaD10
+LlgKcz02CnJldHVybiBQLmpRKEwudHkoTC5RNCgiL2FwcGx5LWhpbnQiLFAuRmwoaCxoKSksbi5hLkx0
+KCkpLCRhc3luYyQkMSkKY2FzZSA2Omg9bi5iCmw9TC5VcyhoLmEpCnM9NwpyZXR1cm4gUC5qUShMLkc3
+KGwsbnVsbCxoLmIsITEsbnVsbCksJGFzeW5jJCQxKQpjYXNlIDc6aS5ib2R5LmNsYXNzTGlzdC5hZGQo
+Im5lZWRzLXJlcnVuIikKaT1pLnF1ZXJ5U2VsZWN0b3IoIi5jb250ZW50IikKaS50b1N0cmluZwppLnNj
+cm9sbFRvcD1KLlZ1KG0pCnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpmPXAKaz1ILlJ1KGYpCmo9SC50
+cyhmKQpMLkMyKCJDb3VsZCBub3QgYXBwbHkgaGludCIsayxqKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpi
+cmVhawpjYXNlIDU6cmV0dXJuIFAueUMobnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpy
+ZXR1cm4gUC5ESSgkYXN5bmMkJDEscil9LAokUzoyMH0KTC5YQS5wcm90b3R5cGU9ewpFYjpmdW5jdGlv
+bihhLGIsYyl7cmV0dXJuITB9LAppMDpmdW5jdGlvbihhKXtyZXR1cm4hMH0sCiRpa0Y6MX0KTC52dC5w
+cm90b3R5cGU9ewpnTDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcy5kCmlmKGwubGVu
+Z3RoPT09MClyZXR1cm4gQy5jdwpzPUMuTm0uZ3RIKGwpLmdMKCkKZm9yKHI9bC5sZW5ndGgscT0hMCxw
+PSEwLG89MDtvPGwubGVuZ3RoO2wubGVuZ3RoPT09cnx8KDAsSC5saykobCksKytvKXtuPWxbb10uZ0wo
+KQppZihuIT1zKXM9bnVsbAptPW4hPT1DLmN3CmlmKG0mJm4hPT1DLldEKXE9ITEKaWYobSYmbiE9PUMu
+WGopcD0hMX1pZihzIT1udWxsKXJldHVybiBzCmlmKHEpcmV0dXJuIEMuV0QKaWYocClyZXR1cm4gQy5Y
+agpyZXR1cm4gQy5kY30sCkxWOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMuZAppZihxIT1udWxsKWZv
+cihzPXEubGVuZ3RoLHI9MDtyPHM7KytyKXFbcl0uYj10aGlzfSwKYzI6ZnVuY3Rpb24oKXt2YXIgcyxy
+LHEscApmb3Iocz10aGlzLmQscj1zLmxlbmd0aCxxPTA7cTxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgw
+LEgubGspKHMpLCsrcSl7cD1zW3FdCmlmKHAgaW5zdGFuY2VvZiBMLnZ0KXAuYzIoKQplbHNlIGlmKHAg
+aW5zdGFuY2VvZiBMLmNEJiZILm9UKHAueCkmJnAucj09PUMuWGopcC5yPUMuV0R9fSwKbkc6ZnVuY3Rp
+b24oKXt2YXIgcyxyLHEscApmb3Iocz10aGlzLmQscj1zLmxlbmd0aCxxPTA7cTxzLmxlbmd0aDtzLmxl
+bmd0aD09PXJ8fCgwLEgubGspKHMpLCsrcSl7cD1zW3FdCmlmKHAgaW5zdGFuY2VvZiBMLnZ0KXAubkco
+KQplbHNlIGlmKHAgaW5zdGFuY2VvZiBMLmNEJiZILm9UKHAueCkmJnAucj09PUMuV0QpcC5yPUMuWGp9
+fSwKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyPVAuRmwodC5YLHQuXykKci5ZNSgwLCJ0eXBlIiwiZGlyZWN0
+b3J5IikKci5ZNSgwLCJuYW1lIix0aGlzLmEpCnIuWTUoMCwic3VidHJlZSIsTC5WRCh0aGlzLmQpKQpz
+PXRoaXMuYwppZihzIT1udWxsKXIuWTUoMCwicGF0aCIscykKcmV0dXJuIHJ9fQpMLmNELnByb3RvdHlw
+ZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9UC5GbCh0LlgsdC5fKQpxLlk1KDAsInR5cGUi
+LCJmaWxlIikKcS5ZNSgwLCJuYW1lIixyLmEpCnM9ci5jCmlmKHMhPW51bGwpcS5ZNSgwLCJwYXRoIixz
+KQpzPXIuZAppZihzIT1udWxsKXEuWTUoMCwiaHJlZiIscykKcz1yLmUKaWYocyE9bnVsbClxLlk1KDAs
+ImVkaXRDb3VudCIscykKcz1yLmYKaWYocyE9bnVsbClxLlk1KDAsIndhc0V4cGxpY2l0bHlPcHRlZE91
+dCIscykKcz1yLnIKaWYocyE9bnVsbClxLlk1KDAsIm1pZ3JhdGlvblN0YXR1cyIscy5hKQpzPXIueApp
+ZihzIT1udWxsKXEuWTUoMCwibWlncmF0aW9uU3RhdHVzQ2FuQmVDaGFuZ2VkIixzKQpyZXR1cm4gcX0s
+CmdMOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMucn19CkwuRDgucHJvdG90eXBlPXt9CkwuTzkucHJvdG90
+eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ifX0KTC5HYi5wcm90b3R5cGU9ewp3OmZ1bmN0
+aW9uKGEpe3JldHVybiB0aGlzLmJ9fQpSLkxMLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJu
+IFAuRUYoWyJub2RlSWQiLHRoaXMuYiwia2luZCIsdGhpcy5hLmFdLHQuWCx0Ll8pfX0KUi5NRC5wcm90
+b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5mRS5hKGEpLmE9PT10aGlzLmEucSgwLCJraW5k
+Iil9LAokUzo0OX0KUi5INy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmJ9fQpN
+LmxJLnByb3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7dmFyIHM9RC5hYigpCnJldHVybiBzfSwKV086ZnVu
+Y3Rpb24oYSxiKXt2YXIgcyxyLHE9dC5kNApNLllGKCJhYnNvbHV0ZSIsSC5WTShbYixudWxsLG51bGws
+bnVsbCxudWxsLG51bGwsbnVsbF0scSkpCnM9dGhpcy5hCnM9cy5ZcihiKT4wJiYhcy5oSyhiKQppZihz
+KXJldHVybiBiCnI9SC5WTShbdGhpcy5nbCgpLGIsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLG51bGxd
+LHEpCk0uWUYoImpvaW4iLHIpCnJldHVybiB0aGlzLklQKG5ldyBILnU2KHIsdC5lSikpfSwKemY6ZnVu
+Y3Rpb24oYSl7dmFyIHMscixxPVguQ0woYSx0aGlzLmEpCnEuSXgoKQpzPXEuZApyPXMubGVuZ3RoCmlm
+KHI9PT0wKXtzPXEuYgpyZXR1cm4gcz09bnVsbD8iLiI6c31pZihyPT09MSl7cz1xLmIKcmV0dXJuIHM9
+PW51bGw/Ii4iOnN9aWYoMD49cilyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnM9cS5lCmlmKDA+PXMu
+bGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcS5JeCgpCnJldHVybiBxLncoMCl9LApJUDpm
+dW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssagp0LlEuYShhKQpmb3Iocz1hLiR0aSxyPXMu
+QygiYTIoY1guRSkiKS5hKG5ldyBNLnE3KCkpLHE9YS5nbShhKSxzPW5ldyBILlNPKHEscixzLkMoIlNP
+PGNYLkU+IikpLHI9dGhpcy5hLHA9ITEsbz0hMSxuPSIiO3MuRigpOyl7bT1xLmdsKCkKaWYoci5oSyht
+KSYmbyl7bD1YLkNMKG0scikKaz1uLmNoYXJDb2RlQXQoMCk9PTA/bjpuCm49Qy54Qi5OaihrLDAsci5T
+cChrLCEwKSkKbC5iPW4KaWYoci5kcyhuKSlDLk5tLlk1KGwuZSwwLHIuZ21JKCkpCm49bC53KDApfWVs
+c2UgaWYoci5ZcihtKT4wKXtvPSFyLmhLKG0pCm49SC5FaihtKX1lbHNle2o9bS5sZW5ndGgKaWYoaiE9
+PTApe2lmKDA+PWopcmV0dXJuIEguT0gobSwwKQpqPXIuVWQobVswXSl9ZWxzZSBqPSExCmlmKCFqKWlm
+KHApbis9ci5nbUkoKQpuKz1tfXA9ci5kcyhtKX1yZXR1cm4gbi5jaGFyQ29kZUF0KDApPT0wP246bn0s
+Cm81OmZ1bmN0aW9uKGEpe3ZhciBzCmlmKCF0aGlzLnkzKGEpKXJldHVybiBhCnM9WC5DTChhLHRoaXMu
+YSkKcy5yUigpCnJldHVybiBzLncoMCl9LAp5MzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxs
+LGssagphLnRvU3RyaW5nCnM9dGhpcy5hCnI9cy5ZcihhKQppZihyIT09MCl7aWYocz09PSQuS2soKSlm
+b3IocT0wO3E8cjsrK3EpaWYoQy54Qi5XKGEscSk9PT00NylyZXR1cm4hMApwPXIKbz00N31lbHNle3A9
+MApvPW51bGx9Zm9yKG49bmV3IEgucWooYSkuYSxtPW4ubGVuZ3RoLHE9cCxsPW51bGw7cTxtOysrcSxs
+PW8sbz1rKXtrPUMueEIuTyhuLHEpCmlmKHMucjQoaykpe2lmKHM9PT0kLktrKCkmJms9PT00NylyZXR1
+cm4hMAppZihvIT1udWxsJiZzLnI0KG8pKXJldHVybiEwCmlmKG89PT00NilqPWw9PW51bGx8fGw9PT00
+Nnx8cy5yNChsKQplbHNlIGo9ITEKaWYoailyZXR1cm4hMH19aWYobz09bnVsbClyZXR1cm4hMAppZihz
+LnI0KG8pKXJldHVybiEwCmlmKG89PT00NilzPWw9PW51bGx8fHMucjQobCl8fGw9PT00NgplbHNlIHM9
+ITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0sCkhQOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxu
+LG0sbD10aGlzLGs9J1VuYWJsZSB0byBmaW5kIGEgcGF0aCB0byAiJwpiPWwuV08oMCxiKQpzPWwuYQpp
+ZihzLllyKGIpPD0wJiZzLllyKGEpPjApcmV0dXJuIGwubzUoYSkKaWYocy5ZcihhKTw9MHx8cy5oSyhh
+KSlhPWwuV08oMCxhKQppZihzLllyKGEpPD0wJiZzLllyKGIpPjApdGhyb3cgSC5iKFguSTcoaytILkVq
+KGEpKyciIGZyb20gIicrSC5FaihiKSsnIi4nKSkKcj1YLkNMKGIscykKci5yUigpCnE9WC5DTChhLHMp
+CnEuclIoKQpwPXIuZApvPXAubGVuZ3RoCmlmKG8hPT0wKXtpZigwPj1vKXJldHVybiBILk9IKHAsMCkK
+cD1KLlJNKHBbMF0sIi4iKX1lbHNlIHA9ITEKaWYocClyZXR1cm4gcS53KDApCnA9ci5iCm89cS5iCmlm
+KHAhPW8pcD1wPT1udWxsfHxvPT1udWxsfHwhcy5OYyhwLG8pCmVsc2UgcD0hMQppZihwKXJldHVybiBx
+LncoMCkKd2hpbGUoITApe3A9ci5kCm89cC5sZW5ndGgKaWYobyE9PTApe249cS5kCm09bi5sZW5ndGgK
+aWYobSE9PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPXBbMF0KaWYoMD49bSlyZXR1cm4gSC5P
+SChuLDApCm49cy5OYyhwLG5bMF0pCnA9bn1lbHNlIHA9ITF9ZWxzZSBwPSExCmlmKCFwKWJyZWFrCkMu
+Tm0uVzQoci5kLDApCkMuTm0uVzQoci5lLDEpCkMuTm0uVzQocS5kLDApCkMuTm0uVzQocS5lLDEpfXA9
+ci5kCm89cC5sZW5ndGgKaWYobyE9PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPUouUk0ocFsw
+XSwiLi4iKX1lbHNlIHA9ITEKaWYocCl0aHJvdyBILmIoWC5JNyhrK0guRWooYSkrJyIgZnJvbSAiJytI
+LkVqKGIpKyciLicpKQpwPXQuTgpDLk5tLlVHKHEuZCwwLFAuTzgoci5kLmxlbmd0aCwiLi4iLCExLHAp
+KQpDLk5tLlk1KHEuZSwwLCIiKQpDLk5tLlVHKHEuZSwxLFAuTzgoci5kLmxlbmd0aCxzLmdtSSgpLCEx
+LHApKQpzPXEuZApwPXMubGVuZ3RoCmlmKHA9PT0wKXJldHVybiIuIgppZihwPjEmJkouUk0oQy5ObS5n
+cloocyksIi4iKSl7cz1xLmQKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpz
+PXEuZQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCmlmKDA+PXMubGVuZ3Ro
+KXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKQy5ObS5pKHMsIiIpfXEuYj0iIgpxLkl4KCkKcmV0dXJu
+IHEudygwKX19Ck0ucTcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEguaChhKSE9PSIi
+fSwKJFM6Nn0KTS5Oby5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILmsoYSkKcmV0dXJuIGE9PW51
+bGw/Im51bGwiOiciJythKyciJ30sCiRTOjUwfQpCLmZ2LnByb3RvdHlwZT17CnhaOmZ1bmN0aW9uKGEp
+e3ZhciBzLHI9dGhpcy5ZcihhKQppZihyPjApcmV0dXJuIEoubGQoYSwwLHIpCmlmKHRoaXMuaEsoYSkp
+e2lmKDA+PWEubGVuZ3RoKXJldHVybiBILk9IKGEsMCkKcz1hWzBdfWVsc2Ugcz1udWxsCnJldHVybiBz
+fSwKTmM6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYT09Yn19ClguV0QucHJvdG90eXBlPXsKSXg6ZnVuY3Rp
+b24oKXt2YXIgcyxyLHE9dGhpcwp3aGlsZSghMCl7cz1xLmQKaWYoIShzLmxlbmd0aCE9PTAmJkouUk0o
+Qy5ObS5ncloocyksIiIpKSlicmVhawpzPXEuZAppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0x
+KQpzLnBvcCgpCnM9cS5lCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCl9cz1x
+LmUKcj1zLmxlbmd0aAppZihyIT09MClDLk5tLlk1KHMsci0xLCIiKX0sCnJSOmZ1bmN0aW9uKCl7dmFy
+IHMscixxLHAsbyxuLG09dGhpcyxsPUguVk0oW10sdC5zKQpmb3Iocz1tLmQscj1zLmxlbmd0aCxxPTAs
+cD0wO3A8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Ape289c1twXQpuPUouaWEo
+bykKaWYoIShuLkROKG8sIi4iKXx8bi5ETihvLCIiKSkpaWYobi5ETihvLCIuLiIpKXtuPWwubGVuZ3Ro
+CmlmKG4hPT0wKXtpZigwPj1uKXJldHVybiBILk9IKGwsLTEpCmwucG9wKCl9ZWxzZSArK3F9ZWxzZSBD
+Lk5tLmkobCxvKX1pZihtLmI9PW51bGwpQy5ObS5VRyhsLDAsUC5POChxLCIuLiIsITEsdC5OKSkKaWYo
+bC5sZW5ndGg9PT0wJiZtLmI9PW51bGwpQy5ObS5pKGwsIi4iKQptLnNuSihsKQpzPW0uYQptLnNQaChQ
+Lk84KGwubGVuZ3RoKzEscy5nbUkoKSwhMCx0Lk4pKQpyPW0uYgppZihyPT1udWxsfHxsLmxlbmd0aD09
+PTB8fCFzLmRzKHIpKUMuTm0uWTUobS5lLDAsIiIpCnI9bS5iCmlmKHIhPW51bGwmJnM9PT0kLktrKCkp
+e3IudG9TdHJpbmcKbS5iPUgueXMociwiLyIsIlxcIil9bS5JeCgpfSwKdzpmdW5jdGlvbihhKXt2YXIg
+cyxyLHE9dGhpcyxwPXEuYgpwPXAhPW51bGw/cDoiIgpmb3Iocz0wO3M8cS5kLmxlbmd0aDsrK3Mpe3I9
+cS5lCmlmKHM+PXIubGVuZ3RoKXJldHVybiBILk9IKHIscykKcj1wK0guRWoocltzXSkKcD1xLmQKaWYo
+cz49cC5sZW5ndGgpcmV0dXJuIEguT0gocCxzKQpwPXIrSC5FaihwW3NdKX1wKz1ILkVqKEMuTm0uZ3Ja
+KHEuZSkpCnJldHVybiBwLmNoYXJDb2RlQXQoMCk9PTA/cDpwfSwKc25KOmZ1bmN0aW9uKGEpe3RoaXMu
+ZD10LkQuYShhKX0sCnNQaDpmdW5jdGlvbihhKXt0aGlzLmU9dC5ELmEoYSl9fQpYLmR2LnByb3RvdHlw
+ZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlBhdGhFeGNlcHRpb246ICIrdGhpcy5hfSwKJGlSejoxfQpP
+LnpMLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ29jKHRoaXMpfX0KRS5PRi5w
+cm90b3R5cGU9ewpVZDpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlv
+bihhKXtyZXR1cm4gYT09PTQ3fSwKZHM6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKcmV0dXJuIHMh
+PT0wJiZDLnhCLk8oYSxzLTEpIT09NDd9LApTcDpmdW5jdGlvbihhLGIpe2lmKGEubGVuZ3RoIT09MCYm
+Qy54Qi5XKGEsMCk9PT00NylyZXR1cm4gMQpyZXR1cm4gMH0sCllyOmZ1bmN0aW9uKGEpe3JldHVybiB0
+aGlzLlNwKGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuITF9LApnb2M6ZnVuY3Rpb24oKXtyZXR1
+cm4icG9zaXgifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJuIi8ifX0KRi5ydS5wcm90b3R5cGU9ewpVZDpm
+dW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihhKXtyZXR1cm4gYT09
+PTQ3fSwKZHM6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKaWYoQy54
+Qi5PKGEscy0xKSE9PTQ3KXJldHVybiEwCnJldHVybiBDLnhCLlRjKGEsIjovLyIpJiZ0aGlzLllyKGEp
+PT09c30sClNwOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz1hLmxlbmd0aAppZihvPT09MClyZXR1
+cm4gMAppZihDLnhCLlcoYSwwKT09PTQ3KXJldHVybiAxCmZvcihzPTA7czxvOysrcyl7cj1DLnhCLlco
+YSxzKQppZihyPT09NDcpcmV0dXJuIDAKaWYocj09PTU4KXtpZihzPT09MClyZXR1cm4gMApxPUMueEIu
+WFUoYSwiLyIsQy54Qi5RaShhLCIvLyIscysxKT9zKzM6cykKaWYocTw9MClyZXR1cm4gbwppZighYnx8
+bzxxKzMpcmV0dXJuIHEKaWYoIUMueEIubihhLCJmaWxlOi8vIikpcmV0dXJuIHEKaWYoIUIuWXUoYSxx
+KzEpKXJldHVybiBxCnA9cSszCnJldHVybiBvPT09cD9wOnErNH19cmV0dXJuIDB9LApZcjpmdW5jdGlv
+bihhKXtyZXR1cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aCE9
+PTAmJkMueEIuVyhhLDApPT09NDd9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4idXJsIn0sCmdtSTpmdW5j
+dGlvbigpe3JldHVybiIvIn19CkwuSVYucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7cmV0dXJuIEMu
+eEIudGcoYSwiLyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N3x8YT09PTkyfSwKZHM6ZnVu
+Y3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKcz1DLnhCLk8oYSxzLTEpCnJl
+dHVybiEocz09PTQ3fHxzPT09OTIpfSwKU3A6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9YS5sZW5ndGgK
+aWYocT09PTApcmV0dXJuIDAKcz1DLnhCLlcoYSwwKQppZihzPT09NDcpcmV0dXJuIDEKaWYocz09PTky
+KXtpZihxPDJ8fEMueEIuVyhhLDEpIT09OTIpcmV0dXJuIDEKcj1DLnhCLlhVKGEsIlxcIiwyKQppZihy
+PjApe3I9Qy54Qi5YVShhLCJcXCIscisxKQppZihyPjApcmV0dXJuIHJ9cmV0dXJuIHF9aWYocTwzKXJl
+dHVybiAwCmlmKCFCLk9TKHMpKXJldHVybiAwCmlmKEMueEIuVyhhLDEpIT09NTgpcmV0dXJuIDAKcT1D
+LnhCLlcoYSwyKQppZighKHE9PT00N3x8cT09PTkyKSlyZXR1cm4gMApyZXR1cm4gM30sCllyOmZ1bmN0
+aW9uKGEpe3JldHVybiB0aGlzLlNwKGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuWXIo
+YSk9PT0xfSwKT3Q6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihhPT09YilyZXR1cm4hMAppZihhPT09NDcp
+cmV0dXJuIGI9PT05MgppZihhPT09OTIpcmV0dXJuIGI9PT00NwppZigoYV5iKSE9PTMyKXJldHVybiEx
+CnM9YXwzMgpyZXR1cm4gcz49OTcmJnM8PTEyMn0sCk5jOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxCmlm
+KGE9PWIpcmV0dXJuITAKcz1hLmxlbmd0aAppZihzIT09Yi5sZW5ndGgpcmV0dXJuITEKZm9yKHI9Si5y
+WShiKSxxPTA7cTxzOysrcSlpZighdGhpcy5PdChDLnhCLlcoYSxxKSxyLlcoYixxKSkpcmV0dXJuITEK
+cmV0dXJuITB9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4id2luZG93cyJ9LApnbUk6ZnVuY3Rpb24oKXty
+ZXR1cm4iXFwifX07KGZ1bmN0aW9uIGFsaWFzZXMoKXt2YXIgcz1KLkd2LnByb3RvdHlwZQpzLlU9cy53
+CnMuU2o9cy5lNwpzPUouTUYucHJvdG90eXBlCnMudD1zLncKcz1QLmNYLnByb3RvdHlwZQpzLkdHPXMu
+ZXYKcz1QLk1oLnByb3RvdHlwZQpzLnhiPXMudwpzPVcuY3YucHJvdG90eXBlCnMuRFc9cy5yNgpzPVcu
+bTYucHJvdG90eXBlCnMuakY9cy5FYgpzPVAuRTQucHJvdG90eXBlCnMuVXI9cy5xCnMuZTQ9cy5ZNQpz
+PVAuY28ucHJvdG90eXBlCnMuYmg9cy5ZNX0pKCk7KGZ1bmN0aW9uIGluc3RhbGxUZWFyT2Zmcygpe3Zh
+ciBzPWh1bmtIZWxwZXJzLl9zdGF0aWNfMSxyPWh1bmtIZWxwZXJzLl9zdGF0aWNfMCxxPWh1bmtIZWxw
+ZXJzLmluc3RhbGxJbnN0YW5jZVRlYXJPZmYscD1odW5rSGVscGVycy5pbnN0YWxsU3RhdGljVGVhck9m
+ZixvPWh1bmtIZWxwZXJzLl9pbnN0YW5jZV8xdQpzKFAsIkVYIiwiWlYiLDgpCnMoUCwieXQiLCJvQSIs
+OCkKcyhQLCJxVyIsIkJ6Iiw4KQpyKFAsIlVJIiwiZU4iLDApCnEoUC5QZi5wcm90b3R5cGUsImdZSiIs
+MCwxLG51bGwsWyIkMiIsIiQxIl0sWyJ3MCIsInBtIl0sMjYsMCkKcyhQLCJDeSIsIk5DIiw0KQpzKFAs
+IlBIIiwiTXQiLDUpCnAoVywicFMiLDQsbnVsbCxbIiQ0Il0sWyJxRCJdLDksMCkKcChXLCJWNCIsNCxu
+dWxsLFsiJDQiXSxbIlFXIl0sOSwwKQpvKFAuQXMucHJvdG90eXBlLCJndU0iLCJWIiw1KQpzKFAsImlH
+Iiwid1kiLDUzKQpzKFAsIncwIiwiZFUiLDM2KQpzKEwsImlTIiwiaTYiLDcpfSkoKTsoZnVuY3Rpb24g
+aW5oZXJpdGFuY2UoKXt2YXIgcz1odW5rSGVscGVycy5taXhpbixyPWh1bmtIZWxwZXJzLmluaGVyaXQs
+cT1odW5rSGVscGVycy5pbmhlcml0TWFueQpyKFAuTWgsbnVsbCkKcShQLk1oLFtILkZLLEouR3YsSi5t
+MSxQLmNYLEguRTcsUC5YUyxQLm5ZLEguYTcsUC5BbixILkZ1LEguSkIsSC5TVSxILlJlLEgud3YsUC5Q
+bixILldVLEguTEksSC5UcCxILmY5LEgudGUsSC5icSxILlhPLEgua3IsUC5ZayxILnZoLEguTjYsSC5W
+UixILkVLLEguUGIsSC50USxILlNkLEguSmMsSC5HLEgubFksUC5XMyxQLmloLFAuRnksUC5HVixQLkN3
+LFAuUGYsUC5GZSxQLnZzLFAuT00sUC5xaCxQLk1PLFAua1QsUC54SSxQLm0wLFAucFIsUC5ibixQLmxt
+LFAubEQsUC5LUCxQLmxmLFAuV1ksUC5VayxQLlNoLFAuUncsUC5ieixQLmlQLFAuazUsUC5LWSxQLkNE
+LFAuYUUsUC5OMyxQLmM4LFAuWmQsUC5SbixQLkRuLFAuUEUsUC5VZixXLmlkLFcuRmssVy5KUSxXLkdt
+LFcudkQsVy5tNixXLk93LFcuVzksVy5kVyxXLm1rLFcuS28sUC5pSixQLkU0LFUuZDIsVS5TZSxVLk1s
+LFUueUQsVS53YixCLmo4LEIucXAsVC5tUSxMLlhBLEwuRDgsTC5POSxMLkdiLFIuTEwsUi5INyxNLmxJ
+LE8uekwsWC5XRCxYLmR2XSkKcShKLkd2LFtKLnlFLEoud2UsSi5NRixKLmpkLEoucUksSi5EcixILkVU
+LFcuRDAsVy5BeixXLkxlLFcuTmgsVy5hZSxXLklCLFcubjcsVy5lYSxXLmJyLFcuU2csVy53NyxXLks3
+LFcuWFcsUC5oRl0pCnEoSi5NRixbSi5pQyxKLmtkLEouYzVdKQpyKEouUG8sSi5qZCkKcShKLnFJLFtK
+LmJVLEouVkFdKQpxKFAuY1gsW0guQlIsSC5iUSxILmkxLEguVTUsSC5BTSxILnU2LEguWFIsUC5tVyxI
+LnVuXSkKcShILkJSLFtILlp5LEguUUNdKQpyKEgub2wsSC5aeSkKcihILlVxLEguUUMpCnIoSC5qVixI
+LlVxKQpxKFAuWFMsW0gubixILnIzLEguR00sUC5FeixILmF6LEgudlYsSC5FcSxQLkM2LEgua1MsUC5V
+ZCxQLkYsUC51LFAubXAsUC51YixQLmRzLFAubGosUC5VVixQLmNdKQpyKFAudXksUC5uWSkKcShQLnV5
+LFtILncyLFcud3osVy5lN10pCnIoSC5xaixILncyKQpxKEguYlEsW0guYUwsSC5NQixILmk1XSkKcShI
+LmFMLFtILm5ILEgubEosUC5pOF0pCnIoSC54eSxILmkxKQpxKFAuQW4sW0guTUgsSC5TTyxILlUxXSkK
+cihILmQ1LEguQU0pCnIoUC5SVSxQLlBuKQpyKFAuR2osUC5SVSkKcihILlBELFAuR2opCnIoSC5MUCxI
+LldVKQpxKEguVHAsW0guQ2osSC5sYyxILmRDLEgud04sSC5WWCxQLnRoLFAuaGEsUC5WcyxQLkZ0LFAu
+eUgsUC5XTSxQLlNYLFAuR3MsUC5kYSxQLm9RLFAucFYsUC5VNyxQLnZyLFAucnQsUC5LRixQLlpMLFAu
+UlQsUC5qWixQLnJxLFAuUlcsUC5CNSxQLnVPLFAucEssUC5oaixQLlZwLFAuT1IsUC5yYSxQLnlRLFAu
+eHIsUC5OeixQLnRpLFAuV0YsUC5uMSxQLmNTLFAuVkMsUC5KVCxQLlJaLFAuTUUsUC55NSxQLnlJLFAu
+YzYsUC5xZCxXLkN2LFcuS1MsVy5BMyxXLnZOLFcuVXYsVy5FZyxXLkVvLFcuV2ssVy5JQSxXLmZtLFAu
+amcsUC5UYSxQLkdFLFAuTjcsUC51USxQLlBDLFAubXQsUC5RUyxQLm5wLFAuVXQsVS5hTixVLmIwLEwu
+ZSxMLlZXLEwub1osTC5qcixMLnFsLEwuSGksTC5CVCxMLlBZLEwudTgsTC5MLEwuV3gsTC5BTyxMLmRO
+LEwuSG8sTC54eixMLklDLEwuZkMsTC5uVCxMLk5ZLEwudWUsTC5lWCxMLkVFLEwuUUwsTC5WUyxMLlRE
+LEwuSWYsTC50QixMLm0yLFIuTUQsTS5xNyxNLk5vXSkKcihILlcwLFAuRXopCnEoSC5sYyxbSC56eCxI
+LnJUXSkKcihILmtZLFAuQzYpCnIoUC5pbCxQLllrKQpxKFAuaWwsW0guTjUsUC51dyxXLmNmLFcuU3ld
+KQpxKFAubVcsW0guS1csUC5xNF0pCnIoSC5MWixILkVUKQpxKEguTFosW0guUkcsSC5XQl0pCnIoSC5W
+UCxILlJHKQpyKEguRGcsSC5WUCkKcihILlpHLEguV0IpCnIoSC5QZyxILlpHKQpxKEguUGcsW0gueGos
+SC5kRSxILlpBLEguZFQsSC5QcSxILmVFLEguVjZdKQpyKEguaU0sSC5rUykKcihQLlpmLFAuUGYpCnIo
+UC5KaSxQLm0wKQpyKFAuWHYsUC5wUikKcihQLmI2LFAuWHYpCnIoUC5WaixQLldZKQpxKFAuVWssW1Au
+Q1YsUC5aaSxQLmJ5XSkKcihQLndJLFAua1QpCnEoUC53SSxbUC5VOCxQLm9qLFAuTXgsUC5FMyxQLkdZ
+XSkKcihQLks4LFAuVWQpCnIoUC50dSxQLlNoKQpyKFAudTUsUC5aaSkKcShQLnUsW1AuYkosUC5lWV0p
+CnIoUC5xZSxQLkRuKQpxKFcuRDAsW1cudUgsVy53YSxXLks1LFcuQ21dKQpxKFcudUgsW1cuY3YsVy5u
+eCxXLlFGLFcuQ1FdKQpxKFcuY3YsW1cucUUsUC5oaV0pCnEoVy5xRSxbVy5HaCxXLmZZLFcubkIsVy5R
+UCxXLmg0LFcuU04sVy5scCxXLlRiLFcuSXYsVy5XUCxXLnlZXSkKcihXLm9KLFcuTGUpCnIoVy5oSCxX
+LkF6KQpyKFcuVmIsVy5RRikKcihXLmZKLFcud2EpCnEoVy5lYSxbVy53NixXLmV3XSkKcihXLkFqLFcu
+dzYpCnIoVy5yQixXLks3KQpyKFcuQkgsVy5yQikKcihXLnc0LFcuSUIpCnIoVy5vYSxXLlhXKQpyKFcu
+cmgsVy5vYSkKcihXLmk3LFcuY2YpCnIoUC5BcyxQLlZqKQpxKFAuQXMsW1cuSTQsUC5LZV0pCnIoVy5S
+TyxQLnFoKQpyKFcuZXUsVy5STykKcihXLnhDLFAuTU8pCnIoVy5jdCxXLm02KQpyKFAuQmYsUC5pSikK
+cShQLkU0LFtQLnI3LFAuY29dKQpyKFAuVHosUC5jbykKcihQLm5kLFAuaGkpCnEoTC5EOCxbTC52dCxM
+LmNEXSkKcihCLmZ2LE8uekwpCnEoQi5mdixbRS5PRixGLnJ1LEwuSVZdKQpzKEgudzIsSC5SZSkKcyhI
+LlFDLFAubEQpCnMoSC5SRyxQLmxEKQpzKEguVlAsSC5TVSkKcyhILldCLFAubEQpCnMoSC5aRyxILlNV
+KQpzKFAublksUC5sRCkKcyhQLldZLFAubGYpCnMoUC5SVSxQLktQKQpzKFAucFIsUC5sZikKcyhXLkxl
+LFcuaWQpCnMoVy5LNyxQLmxEKQpzKFcuckIsVy5HbSkKcyhXLlhXLFAubEQpCnMoVy5vYSxXLkdtKQpz
+KFAuY28sUC5sRCl9KSgpCnZhciB2PXt0eXBlVW5pdmVyc2U6e2VDOm5ldyBNYXAoKSx0Ujp7fSxlVDp7
+fSx0UFY6e30sc0VBOltdfSxtYW5nbGVkR2xvYmFsTmFtZXM6e0IyOiJpbnQiLENQOiJkb3VibGUiLFpa
+OiJudW0iLHFVOiJTdHJpbmciLGEyOiJib29sIixjODoiTnVsbCIsek06Ikxpc3QifSxtYW5nbGVkTmFt
+ZXM6e30sZ2V0VHlwZUZyb21OYW1lOmdldEdsb2JhbEZyb21OYW1lLG1ldGFkYXRhOltdLHR5cGVzOlsi
+figpIiwiYzgoQWoqKSIsImM4KCkiLCJjOChjdiopIiwiQChAKSIsInFVKHFVKSIsImEyKHFVKSIsIn4o
+QWoqKSIsIn4ofigpKSIsImEyKGN2LHFVLHFVLEpRKSIsImM4KEApIiwifihNaD8sTWg/KSIsIkAoKSIs
+In4ocVUsQCkiLCJ+KG42LHFVLEIyKSIsIn4ocVUscVUpIiwiYTIoa0YpIiwiYzgoQCxAKSIsIn4oeHU8
+cVU+KSIsImM4KGVhKikiLCJiODxjOD4qKEFqKikiLCJ+KHFVLEIyKSIsIn4ocVUscVU/KSIsIm42KEAs
+QCkiLCJ+KEIyLEApIiwiYTIodUgpIiwifihNaFtHej9dKSIsIn4oZWEpIiwiYzgoTWgsR3opIiwidnM8
+QD4oQCkiLCJ+KHVILHVIPykiLCJ+KEAsQCkiLCJAKHFVKSIsImEyKHh1PHFVPikiLCJAKEAscVUpIiwi
+cjcoQCkiLCJNaD8oQCkiLCJFNChAKSIsIkxMKihAKSIsIlowPHFVKixNaCo+KihMTCopIiwifihHRCxA
+KSIsIlowPHFVLHFVPihaMDxxVSxxVT4scVUpIiwiYzgoWjA8cVUqLE1oKj4qKSIsIn4oQCkiLCJxVSoo
+QWoqKSIsIlR6PEA+KEApIiwifihxVVtAXSkiLCJjOChldyopIiwicVUqKFowPEAsQD4qKSIsImEyKihI
+NyopIiwicVUocVU/KSIsIkIyKEIyLEIyKSIsImM4KH4oKSkiLCJNaD8oTWg/KSIsImM4KEAsR3opIl0s
+aW50ZXJjZXB0b3JzQnlUYWc6bnVsbCxsZWFmVGFnczpudWxsLGFycmF5UnRpOnR5cGVvZiBTeW1ib2w9
+PSJmdW5jdGlvbiImJnR5cGVvZiBTeW1ib2woKT09InN5bWJvbCI/U3ltYm9sKCIkdGkiKToiJHRpIn0K
+SC54Yih2LnR5cGVVbml2ZXJzZSxKU09OLnBhcnNlKCd7ImM1IjoiTUYiLCJpQyI6Ik1GIiwia2QiOiJN
+RiIsInJ4IjoiZWEiLCJlNSI6ImVhIiwiWTAiOiJoaSIsInRwIjoiaGkiLCJHOCI6ImV3IiwiTXIiOiJx
+RSIsImVMIjoicUUiLCJJMCI6InVIIiwiaHMiOiJ1SCIsIlhnIjoiUUYiLCJuciI6IkFqIiwieTQiOiJ3
+NiIsImFQIjoiQ20iLCJ4YyI6Im54Iiwia0oiOiJueCIsInpVIjoiRGciLCJkZiI6IkVUIiwieUUiOnsi
+YTIiOltdfSwid2UiOnsiYzgiOltdfSwiTUYiOnsidm0iOltdLCJFSCI6W119LCJqZCI6eyJ6TSI6WyIx
+Il0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiUG8iOnsiamQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpb
+IjEiXSwiY1giOlsiMSJdfSwibTEiOnsiQW4iOlsiMSJdfSwicUkiOnsiQ1AiOltdLCJaWiI6W119LCJi
+VSI6eyJDUCI6W10sIkIyIjpbXSwiWloiOltdfSwiVkEiOnsiQ1AiOltdLCJaWiI6W119LCJEciI6eyJx
+VSI6W10sInZYIjpbXX0sIkJSIjp7ImNYIjpbIjIiXX0sIkU3Ijp7IkFuIjpbIjIiXX0sIlp5Ijp7IkJS
+IjpbIjEiLCIyIl0sImNYIjpbIjIiXSwiY1guRSI6IjIifSwib2wiOnsiWnkiOlsiMSIsIjIiXSwiQlIi
+OlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIlVxIjp7ImxEIjpbIjIi
+XSwiek0iOlsiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNYIjpbIjIiXX0sImpWIjp7IlVx
+IjpbIjEiLCIyIl0sImxEIjpbIjIiXSwiek0iOlsiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0s
+ImNYIjpbIjIiXSwibEQuRSI6IjIiLCJjWC5FIjoiMiJ9LCJuIjp7IlhTIjpbXX0sInIzIjp7IlhTIjpb
+XX0sInFqIjp7ImxEIjpbIkIyIl0sIlJlIjpbIkIyIl0sInpNIjpbIkIyIl0sImJRIjpbIkIyIl0sImNY
+IjpbIkIyIl0sImxELkUiOiJCMiIsIlJlLkUiOiJCMiJ9LCJHTSI6eyJYUyI6W119LCJiUSI6eyJjWCI6
+WyIxIl19LCJhTCI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIm5IIjp7ImFMIjpbIjEiXSwiYlEiOlsi
+MSJdLCJjWCI6WyIxIl0sImFMLkUiOiIxIiwiY1guRSI6IjEifSwiYTciOnsiQW4iOlsiMSJdfSwiaTEi
+OnsiY1giOlsiMiJdLCJjWC5FIjoiMiJ9LCJ4eSI6eyJpMSI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNY
+IjpbIjIiXSwiY1guRSI6IjIifSwiTUgiOnsiQW4iOlsiMiJdfSwibEoiOnsiYUwiOlsiMiJdLCJiUSI6
+WyIyIl0sImNYIjpbIjIiXSwiYUwuRSI6IjIiLCJjWC5FIjoiMiJ9LCJVNSI6eyJjWCI6WyIxIl0sImNY
+LkUiOiIxIn0sIlNPIjp7IkFuIjpbIjEiXX0sIkFNIjp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiZDUi
+OnsiQU0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwiY1guRSI6IjEifSwiVTEiOnsiQW4iOlsi
+MSJdfSwiTUIiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkZ1Ijp7IkFuIjpbIjEi
+XX0sInU2Ijp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiSkIiOnsiQW4iOlsiMSJdfSwidzIiOnsibEQi
+OlsiMSJdLCJSZSI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJ3diI6eyJH
+RCI6W119LCJQRCI6eyJHaiI6WyIxIiwiMiJdLCJSVSI6WyIxIiwiMiJdLCJQbiI6WyIxIiwiMiJdLCJL
+UCI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiV1UiOnsiWjAiOlsiMSIsIjIiXX0sIkxQIjp7IldV
+IjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19LCJYUiI6eyJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkxJ
+Ijp7InZRIjpbXX0sIlcwIjp7IlhTIjpbXX0sImF6Ijp7IlhTIjpbXX0sInZWIjp7IlhTIjpbXX0sInRl
+Ijp7IlJ6IjpbXX0sIlhPIjp7Ikd6IjpbXX0sIlRwIjp7IkVIIjpbXX0sImxjIjp7IkVIIjpbXX0sInp4
+Ijp7IkVIIjpbXX0sInJUIjp7IkVIIjpbXX0sIkVxIjp7IlhTIjpbXX0sImtZIjp7IlhTIjpbXX0sIk41
+Ijp7IllrIjpbIjEiLCIyIl0sIkZvIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl0sIllrLksiOiIxIiwi
+WWsuViI6IjIifSwiaTUiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIk42Ijp7IkFu
+IjpbIjEiXX0sIlZSIjp7IndMIjpbXSwidlgiOltdfSwiRUsiOnsiaWIiOltdLCJPZCI6W119LCJLVyI6
+eyJjWCI6WyJpYiJdLCJjWC5FIjoiaWIifSwiUGIiOnsiQW4iOlsiaWIiXX0sInRRIjp7Ik9kIjpbXX0s
+InVuIjp7ImNYIjpbIk9kIl0sImNYLkUiOiJPZCJ9LCJTZCI6eyJBbiI6WyJPZCJdfSwiRVQiOnsiQVMi
+OltdfSwiTFoiOnsiWGoiOlsiMSJdLCJFVCI6W10sIkFTIjpbXX0sIkRnIjp7ImxEIjpbIkNQIl0sIlhq
+IjpbIkNQIl0sInpNIjpbIkNQIl0sIkVUIjpbXSwiYlEiOlsiQ1AiXSwiQVMiOltdLCJjWCI6WyJDUCJd
+LCJTVSI6WyJDUCJdLCJsRC5FIjoiQ1AifSwiUGciOnsibEQiOlsiQjIiXSwiWGoiOlsiQjIiXSwiek0i
+OlsiQjIiXSwiRVQiOltdLCJiUSI6WyJCMiJdLCJBUyI6W10sImNYIjpbIkIyIl0sIlNVIjpbIkIyIl19
+LCJ4aiI6eyJsRCI6WyJCMiJdLCJYaiI6WyJCMiJdLCJ6TSI6WyJCMiJdLCJFVCI6W10sImJRIjpbIkIy
+Il0sIkFTIjpbXSwiY1giOlsiQjIiXSwiU1UiOlsiQjIiXSwibEQuRSI6IkIyIn0sImRFIjp7ImxEIjpb
+IkIyIl0sIlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwiYlEiOlsiQjIiXSwiQVMiOltdLCJj
+WCI6WyJCMiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwiWkEiOnsibEQiOlsiQjIiXSwiWGoiOlsi
+QjIiXSwiek0iOlsiQjIiXSwiRVQiOltdLCJiUSI6WyJCMiJdLCJBUyI6W10sImNYIjpbIkIyIl0sIlNV
+IjpbIkIyIl0sImxELkUiOiJCMiJ9LCJkVCI6eyJsRCI6WyJCMiJdLCJYaiI6WyJCMiJdLCJ6TSI6WyJC
+MiJdLCJFVCI6W10sImJRIjpbIkIyIl0sIkFTIjpbXSwiY1giOlsiQjIiXSwiU1UiOlsiQjIiXSwibEQu
+RSI6IkIyIn0sIlBxIjp7ImxEIjpbIkIyIl0sIlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwi
+YlEiOlsiQjIiXSwiQVMiOltdLCJjWCI6WyJCMiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwiZUUi
+OnsibEQiOlsiQjIiXSwiWGoiOlsiQjIiXSwiek0iOlsiQjIiXSwiRVQiOltdLCJiUSI6WyJCMiJdLCJB
+UyI6W10sImNYIjpbIkIyIl0sIlNVIjpbIkIyIl0sImxELkUiOiJCMiJ9LCJWNiI6eyJsRCI6WyJCMiJd
+LCJuNiI6W10sIlhqIjpbIkIyIl0sInpNIjpbIkIyIl0sIkVUIjpbXSwiYlEiOlsiQjIiXSwiQVMiOltd
+LCJjWCI6WyJCMiJdLCJTVSI6WyJCMiJdLCJsRC5FIjoiQjIifSwia1MiOnsiWFMiOltdfSwiaU0iOnsi
+WFMiOltdfSwiR1YiOnsiQW4iOlsiMSJdfSwicTQiOnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJDdyI6
+eyJYUyI6W119LCJaZiI6eyJQZiI6WyIxIl19LCJ2cyI6eyJiOCI6WyIxIl19LCJtMCI6eyJRbSI6W119
+LCJKaSI6eyJtMCI6W10sIlFtIjpbXX0sImI2Ijp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIx
+Il0sImNYIjpbIjEiXSwibGYuRSI6IjEifSwibG0iOnsiQW4iOlsiMSJdfSwibVciOnsiY1giOlsiMSJd
+fSwidXkiOnsibEQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiaWwiOnsi
+WWsiOlsiMSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIllrIjp7IlowIjpbIjEiLCIyIl19LCJQbiI6eyJa
+MCI6WyIxIiwiMiJdfSwiR2oiOnsiUlUiOlsiMSIsIjIiXSwiUG4iOlsiMSIsIjIiXSwiS1AiOlsiMSIs
+IjIiXSwiWjAiOlsiMSIsIjIiXX0sIlZqIjp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIxIl0s
+ImNYIjpbIjEiXX0sIlh2Ijp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEi
+XX0sInV3Ijp7IllrIjpbInFVIiwiQCJdLCJaMCI6WyJxVSIsIkAiXSwiWWsuSyI6InFVIiwiWWsuViI6
+IkAifSwiaTgiOnsiYUwiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwiYUwuRSI6InFVIiwi
+Y1guRSI6InFVIn0sIkNWIjp7IlVrIjpbInpNPEIyPiIsInFVIl0sIlVrLlMiOiJ6TTxCMj4ifSwiVTgi
+Onsid0kiOlsiek08QjI+IiwicVUiXX0sIlppIjp7IlVrIjpbInFVIiwiek08QjI+Il19LCJVZCI6eyJY
+UyI6W119LCJLOCI6eyJYUyI6W119LCJieSI6eyJVayI6WyJNaD8iLCJxVSJdLCJVay5TIjoiTWg/In0s
+Im9qIjp7IndJIjpbIk1oPyIsInFVIl19LCJNeCI6eyJ3SSI6WyJxVSIsIk1oPyJdfSwidTUiOnsiVWsi
+OlsicVUiLCJ6TTxCMj4iXSwiVWsuUyI6InFVIn0sIkUzIjp7IndJIjpbInFVIiwiek08QjI+Il19LCJH
+WSI6eyJ3SSI6WyJ6TTxCMj4iLCJxVSJdfSwiQ1AiOnsiWloiOltdfSwiQjIiOnsiWloiOltdfSwiek0i
+OnsiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJpYiI6eyJPZCI6W119LCJ4dSI6eyJiUSI6WyIxIl0sImNY
+IjpbIjEiXX0sInFVIjp7InZYIjpbXX0sIkM2Ijp7IlhTIjpbXX0sIkV6Ijp7IlhTIjpbXX0sIkYiOnsi
+WFMiOltdfSwidSI6eyJYUyI6W119LCJiSiI6eyJYUyI6W119LCJlWSI6eyJYUyI6W119LCJtcCI6eyJY
+UyI6W119LCJ1YiI6eyJYUyI6W119LCJkcyI6eyJYUyI6W119LCJsaiI6eyJYUyI6W119LCJVViI6eyJY
+UyI6W119LCJrNSI6eyJYUyI6W119LCJLWSI6eyJYUyI6W119LCJjIjp7IlhTIjpbXX0sIkNEIjp7IlJ6
+IjpbXX0sImFFIjp7IlJ6IjpbXX0sIlpkIjp7Ikd6IjpbXX0sIlJuIjp7IkJMIjpbXX0sIkRuIjp7ImlE
+IjpbXX0sIlVmIjp7ImlEIjpbXX0sInFlIjp7ImlEIjpbXX0sInFFIjp7ImN2IjpbXSwidUgiOltdLCJE
+MCI6W119LCJHaCI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiZlkiOnsiY3YiOltdLCJ1SCI6W10s
+IkQwIjpbXX0sIm5CIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJRUCI6eyJjdiI6W10sInVIIjpb
+XSwiRDAiOltdfSwibngiOnsidUgiOltdLCJEMCI6W119LCJRRiI6eyJ1SCI6W10sIkQwIjpbXX0sIklC
+Ijp7InRuIjpbIlpaIl19LCJ3eiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6
+WyIxIl0sImxELkUiOiIxIn0sImN2Ijp7InVIIjpbXSwiRDAiOltdfSwiaEgiOnsiQXoiOltdfSwiaDQi
+OnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlZiIjp7InVIIjpbXSwiRDAiOltdfSwiZkoiOnsiRDAi
+OltdfSwid2EiOnsiRDAiOltdfSwiQWoiOnsiZWEiOltdfSwiZTciOnsibEQiOlsidUgiXSwiek0iOlsi
+dUgiXSwiYlEiOlsidUgiXSwiY1giOlsidUgiXSwibEQuRSI6InVIIn0sInVIIjp7IkQwIjpbXX0sIkJI
+Ijp7ImxEIjpbInVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJRIjpbInVI
+Il0sImNYIjpbInVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJTTiI6eyJjdiI6W10sInVIIjpb
+XSwiRDAiOltdfSwiZXciOnsiZWEiOltdfSwibHAiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlRi
+Ijp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJJdiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwi
+V1AiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sInlZIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119
+LCJ3NiI6eyJlYSI6W119LCJLNSI6eyJ2NiI6W10sIkQwIjpbXX0sIkNtIjp7IkQwIjpbXX0sIkNRIjp7
+InVIIjpbXSwiRDAiOltdfSwidzQiOnsidG4iOlsiWloiXX0sInJoIjp7ImxEIjpbInVIIl0sIkdtIjpb
+InVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJRIjpbInVIIl0sImNYIjpbInVIIl0sImxELkUi
+OiJ1SCIsIkdtLkUiOiJ1SCJ9LCJjZiI6eyJZayI6WyJxVSIsInFVIl0sIlowIjpbInFVIiwicVUiXX0s
+Imk3Ijp7IllrIjpbInFVIiwicVUiXSwiWjAiOlsicVUiLCJxVSJdLCJZay5LIjoicVUiLCJZay5WIjoi
+cVUifSwiU3kiOnsiWWsiOlsicVUiLCJxVSJdLCJaMCI6WyJxVSIsInFVIl0sIllrLksiOiJxVSIsIllr
+LlYiOiJxVSJ9LCJJNCI6eyJsZiI6WyJxVSJdLCJ4dSI6WyJxVSJdLCJiUSI6WyJxVSJdLCJjWCI6WyJx
+VSJdLCJsZi5FIjoicVUifSwiUk8iOnsicWgiOlsiMSJdfSwiZXUiOnsiUk8iOlsiMSJdLCJxaCI6WyIx
+Il19LCJ4QyI6eyJNTyI6WyIxIl19LCJKUSI6eyJrRiI6W119LCJ2RCI6eyJrRiI6W119LCJtNiI6eyJr
+RiI6W119LCJjdCI6eyJrRiI6W119LCJPdyI6eyJrRiI6W119LCJXOSI6eyJBbiI6WyIxIl19LCJkVyI6
+eyJ2NiI6W10sIkQwIjpbXX0sIm1rIjp7InkwIjpbXX0sIktvIjp7Im9uIjpbXX0sIkFzIjp7ImxmIjpb
+InFVIl0sInh1IjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFVIl19LCJyNyI6eyJFNCI6W119LCJU
+eiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJFNCI6W10sImNYIjpbIjEiXSwibEQu
+RSI6IjEifSwibmQiOnsiaGkiOltdLCJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiS2UiOnsibGYiOlsi
+cVUiXSwieHUiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwibGYuRSI6InFVIn0sImhpIjp7
+ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJYQSI6eyJrRiI6W119LCJ2dCI6eyJEOCI6W119LCJjRCI6
+eyJEOCI6W119LCJkdiI6eyJSeiI6W119LCJPRiI6eyJmdiI6W119LCJydSI6eyJmdiI6W119LCJJViI6
+eyJmdiI6W119LCJuNiI6eyJ6TSI6WyJCMiJdLCJiUSI6WyJCMiJdLCJjWCI6WyJCMiJdLCJBUyI6W119
+fScpKQpILkZGKHYudHlwZVVuaXZlcnNlLEpTT04ucGFyc2UoJ3sidzIiOjEsIlFDIjoyLCJMWiI6MSwi
+a1QiOjIsIm1XIjoxLCJ1eSI6MSwiaWwiOjIsIlZqIjoxLCJYdiI6MSwiblkiOjEsIldZIjoxLCJwUiI6
+MSwiY28iOjF9JykpCnZhciB1PXtsOiJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEgVVJJ
+IHdpdGggYSBmcmFnbWVudCBjb21wb25lbnQiLGk6IkNhbm5vdCBleHRyYWN0IGEgZmlsZSBwYXRoIGZy
+b20gYSBVUkkgd2l0aCBhIHF1ZXJ5IGNvbXBvbmVudCIsajoiQ2Fubm90IGV4dHJhY3QgYSBub24tV2lu
+ZG93cyBmaWxlIHBhdGggZnJvbSBhIGZpbGUgVVJJIHdpdGggYW4gYXV0aG9yaXR5IixnOiJgbnVsbGAg
+ZW5jb3VudGVyZWQgYXMgdGhlIHJlc3VsdCBmcm9tIGV4cHJlc3Npb24gd2l0aCB0eXBlIGBOZXZlcmAu
+IixkOiJhcmVhLWFuYWx5emVyLGFuYWx5emVyLW5uYmQtbWlncmF0aW9uLHR5cGUtYnVnIn0KdmFyIHQ9
+KGZ1bmN0aW9uIHJ0aWkoKXt2YXIgcz1ILk4wCnJldHVybntuOnMoIkN3IiksY1I6cygibkIiKSx3OnMo
+IkF6IikscDpzKCJRUCIpLGdGOnMoIlBEPEdELEA+IiksZDpzKCJiUTxAPiIpLGg6cygiY3YiKSxyOnMo
+IlhTIiksQjpzKCJlYSIpLGFTOnMoIkQwIiksZzg6cygiUnoiKSxjODpzKCJoSCIpLFk6cygiRUgiKSxl
+OnMoImI4PEA+IiksSTpzKCJTZyIpLG86cygidlEiKSxlaDpzKCJjWDx1SD4iKSxROnMoImNYPHFVPiIp
+LHU6cygiY1g8QD4iKSx2OnMoImpkPGtGPiIpLHM6cygiamQ8cVU+IiksZ046cygiamQ8bjY+IiksYjpz
+KCJqZDxAPiIpLGE6cygiamQ8QjI+IiksZDc6cygiamQ8U2UqPiIpLGg0OnMoImpkPGo4Kj4iKSxHOnMo
+ImpkPFowPHFVKixNaCo+Kj4iKSxjUTpzKCJqZDxEOCo+IiksaTpzKCJqZDxxVSo+IiksYUE6cygiamQ8
+eUQqPiIpLGFKOnMoImpkPHdiKj4iKSxWOnMoImpkPEIyKj4iKSxkNDpzKCJqZDxxVT8+IiksVDpzKCJ3
+ZSIpLGVIOnMoInZtIikseDpzKCJjNSIpLGFVOnMoIlhqPEA+IiksYW06cygiVHo8QD4iKSxlbzpzKCJO
+NTxHRCxAPiIpLGR6OnMoImhGIiksRDpzKCJ6TTxxVT4iKSxqOnMoInpNPEA+IiksTDpzKCJ6TTxCMj4i
+KSxKOnMoIlowPHFVLHFVPiIpLGY6cygiWjA8QCxAPiIpLGRvOnMoImxKPHFVLEA+IiksZmo6cygibEo8
+cVUqLHFVPiIpLGRFOnMoIkVUIiksYm06cygiVjYiKSxBOnMoInVIIiksRTpzKCJrRiIpLFA6cygiYzgi
+KSxLOnMoIk1oIikscTpzKCJ0bjxaWj4iKSxmdjpzKCJ3TCIpLGV3OnMoIm5kIiksQzpzKCJ4dTxxVT4i
+KSxsOnMoIkd6IiksTjpzKCJxVSIpLGQwOnMoInFVKHFVKikiKSxnNzpzKCJoaSIpLGZvOnMoIkdEIiks
+YVc6cygieVkiKSxhazpzKCJBUyIpLGdjOnMoIm42IiksYko6cygia2QiKSxkdzpzKCJHajxxVSxxVT4i
+KSxkRDpzKCJpRCIpLGVKOnMoInU2PHFVPiIpLGc0OnMoIks1IiksY2k6cygidjYiKSxnMjpzKCJDbSIp
+LGJDOnMoIlpmPGZKKj4iKSxoOTpzKCJDUSIpLGFjOnMoImU3IiksazpzKCJldTxBaio+IiksUjpzKCJ3
+ejxjdio+IiksYzpzKCJ2czxAPiIpLGZKOnMoInZzPEIyPiIpLGdWOnMoInZzPGZKKj4iKSxjcjpzKCJK
+USIpLHk6cygiYTIiKSxhbDpzKCJhMihNaCkiKSxnUjpzKCJDUCIpLHo6cygiQCIpLGZPOnMoIkAoKSIp
+LGJJOnMoIkAoTWgpIiksYWc6cygiQChNaCxHeikiKSxiVTpzKCJAKHh1PHFVPikiKSxkTzpzKCJAKHFV
+KSIpLGI4OnMoIkAoQCxAKSIpLFM6cygiQjIiKSxkZDpzKCJHaCoiKSxnOnMoImN2KiIpLGFMOnMoImVh
+KiIpLGFYOnMoIkxMKiIpLGZFOnMoIkg3KiIpLFU6cygiY1g8QD4qIiksZEg6cygiRTQqIiksZks6cygi
+ek08QD4qIiksZF86cygiek08ajgqPioiKSxkcDpzKCJ6TTxaMDxxVSosTWgqPio+KiIpLGVFOnMoInpN
+PE1oKj4qIiksYXc6cygiWjA8QCxAPioiKSx0OnMoIlowPHFVKixNaCo+KiIpLE86cygiQWoqIiksY0Y6
+cygiMCYqIiksXzpzKCJNaCoiKSxlUTpzKCJldyoiKSxYOnMoInFVKiIpLGNoOnMoIkQwPyIpLGJHOnMo
+ImI4PGM4Pj8iKSxiazpzKCJ6TTxxVT4/IiksYk06cygiek08QD4/IiksY1o6cygiWjA8cVUscVU+PyIp
+LGM5OnMoIlowPHFVLEA+PyIpLFc6cygiTWg/IiksRjpzKCJGZTxALEA+PyIpLG06cygiYm4/IiksYjc6
+cygiYTIoTWgpPyIpLGJ3OnMoIkAoZWEpPyIpLGZWOnMoIk1oPyhNaD8sTWg/KT8iKSxkQTpzKCJNaD8o
+QCk/IiksWjpzKCJ+KCk/IiksZWI6cygifihldyopPyIpLGRpOnMoIlpaIiksSDpzKCJ+IiksTTpzKCJ+
+KCkiKSxlQTpzKCJ+KHFVLHFVKSIpLGNBOnMoIn4ocVUsQCkiKX19KSgpOyhmdW5jdGlvbiBjb25zdGFu
+dHMoKXt2YXIgcz1odW5rSGVscGVycy5tYWtlQ29uc3RMaXN0CkMueG49Vy5HaC5wcm90b3R5cGUKQy5S
+WT1XLlFQLnByb3RvdHlwZQpDLm1IPVcuYWUucHJvdG90eXBlCkMuQlo9Vy5WYi5wcm90b3R5cGUKQy5E
+dD1XLmZKLnByb3RvdHlwZQpDLk9rPUouR3YucHJvdG90eXBlCkMuTm09Si5qZC5wcm90b3R5cGUKQy5q
+bj1KLmJVLnByb3RvdHlwZQpDLmpOPUoud2UucHJvdG90eXBlCkMuQ0Q9Si5xSS5wcm90b3R5cGUKQy54
+Qj1KLkRyLnByb3RvdHlwZQpDLkRHPUouYzUucHJvdG90eXBlCkMuRXg9Vy53Ny5wcm90b3R5cGUKQy5O
+QT1ILlY2LnByb3RvdHlwZQpDLnQ1PVcuQkgucHJvdG90eXBlCkMuTHQ9Vy5TTi5wcm90b3R5cGUKQy5a
+UT1KLmlDLnByb3RvdHlwZQpDLkllPVcuVGIucHJvdG90eXBlCkMudkI9Si5rZC5wcm90b3R5cGUKQy5v
+bD1XLks1LnByb3RvdHlwZQpDLnk4PW5ldyBQLlU4KCkKQy5oOT1uZXcgUC5DVigpCkMuR3c9bmV3IEgu
+RnUoSC5OMCgiRnU8Yzg+IikpCkMuTzQ9ZnVuY3Rpb24gZ2V0VGFnRmFsbGJhY2sobykgewogIHZhciBz
+ID0gT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKG8pOwogIHJldHVybiBzLnN1YnN0cmluZyg4
+LCBzLmxlbmd0aCAtIDEpOwp9CkMuWXE9ZnVuY3Rpb24oKSB7CiAgdmFyIHRvU3RyaW5nRnVuY3Rpb24g
+PSBPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nOwogIGZ1bmN0aW9uIGdldFRhZyhvKSB7CiAgICB2YXIg
+cyA9IHRvU3RyaW5nRnVuY3Rpb24uY2FsbChvKTsKICAgIHJldHVybiBzLnN1YnN0cmluZyg4LCBzLmxl
+bmd0aCAtIDEpOwogIH0KICBmdW5jdGlvbiBnZXRVbmtub3duVGFnKG9iamVjdCwgdGFnKSB7CiAgICBp
+ZiAoL15IVE1MW0EtWl0uKkVsZW1lbnQkLy50ZXN0KHRhZykpIHsKICAgICAgdmFyIG5hbWUgPSB0b1N0
+cmluZ0Z1bmN0aW9uLmNhbGwob2JqZWN0KTsKICAgICAgaWYgKG5hbWUgPT0gIltvYmplY3QgT2JqZWN0
+XSIpIHJldHVybiBudWxsOwogICAgICByZXR1cm4gIkhUTUxFbGVtZW50IjsKICAgIH0KICB9CiAgZnVu
+Y3Rpb24gZ2V0VW5rbm93blRhZ0dlbmVyaWNCcm93c2VyKG9iamVjdCwgdGFnKSB7CiAgICBpZiAoc2Vs
+Zi5IVE1MRWxlbWVudCAmJiBvYmplY3QgaW5zdGFuY2VvZiBIVE1MRWxlbWVudCkgcmV0dXJuICJIVE1M
+RWxlbWVudCI7CiAgICByZXR1cm4gZ2V0VW5rbm93blRhZyhvYmplY3QsIHRhZyk7CiAgfQogIGZ1bmN0
+aW9uIHByb3RvdHlwZUZvclRhZyh0YWcpIHsKICAgIGlmICh0eXBlb2Ygd2luZG93ID09ICJ1bmRlZmlu
+ZWQiKSByZXR1cm4gbnVsbDsKICAgIGlmICh0eXBlb2Ygd2luZG93W3RhZ10gPT0gInVuZGVmaW5lZCIp
+IHJldHVybiBudWxsOwogICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBpZiAodHlw
+ZW9mIGNvbnN0cnVjdG9yICE9ICJmdW5jdGlvbiIpIHJldHVybiBudWxsOwogICAgcmV0dXJuIGNvbnN0
+cnVjdG9yLnByb3RvdHlwZTsKICB9CiAgZnVuY3Rpb24gZGlzY3JpbWluYXRvcih0YWcpIHsgcmV0dXJu
+IG51bGw7IH0KICB2YXIgaXNCcm93c2VyID0gdHlwZW9mIG5hdmlnYXRvciA9PSAib2JqZWN0IjsKICBy
+ZXR1cm4gewogICAgZ2V0VGFnOiBnZXRUYWcsCiAgICBnZXRVbmtub3duVGFnOiBpc0Jyb3dzZXIgPyBn
+ZXRVbmtub3duVGFnR2VuZXJpY0Jyb3dzZXIgOiBnZXRVbmtub3duVGFnLAogICAgcHJvdG90eXBlRm9y
+VGFnOiBwcm90b3R5cGVGb3JUYWcsCiAgICBkaXNjcmltaW5hdG9yOiBkaXNjcmltaW5hdG9yIH07Cn0K
+Qy53Yj1mdW5jdGlvbihnZXRUYWdGYWxsYmFjaykgewogIHJldHVybiBmdW5jdGlvbihob29rcykgewog
+ICAgaWYgKHR5cGVvZiBuYXZpZ2F0b3IgIT0gIm9iamVjdCIpIHJldHVybiBob29rczsKICAgIHZhciB1
+YSA9IG5hdmlnYXRvci51c2VyQWdlbnQ7CiAgICBpZiAodWEuaW5kZXhPZigiRHVtcFJlbmRlclRyZWUi
+KSA+PSAwKSByZXR1cm4gaG9va3M7CiAgICBpZiAodWEuaW5kZXhPZigiQ2hyb21lIikgPj0gMCkgewog
+ICAgICBmdW5jdGlvbiBjb25maXJtKHApIHsKICAgICAgICByZXR1cm4gdHlwZW9mIHdpbmRvdyA9PSAi
+b2JqZWN0IiAmJiB3aW5kb3dbcF0gJiYgd2luZG93W3BdLm5hbWUgPT0gcDsKICAgICAgfQogICAgICBp
+ZiAoY29uZmlybSgiV2luZG93IikgJiYgY29uZmlybSgiSFRNTEVsZW1lbnQiKSkgcmV0dXJuIGhvb2tz
+OwogICAgfQogICAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRmFsbGJhY2s7CiAgfTsKfQpDLktVPWZ1bmN0
+aW9uKGhvb2tzKSB7CiAgaWYgKHR5cGVvZiBkYXJ0RXhwZXJpbWVudGFsRml4dXBHZXRUYWcgIT0gImZ1
+bmN0aW9uIikgcmV0dXJuIGhvb2tzOwogIGhvb2tzLmdldFRhZyA9IGRhcnRFeHBlcmltZW50YWxGaXh1
+cEdldFRhZyhob29rcy5nZXRUYWcpOwp9CkMuZlE9ZnVuY3Rpb24oaG9va3MpIHsKICB2YXIgZ2V0VGFn
+ID0gaG9va3MuZ2V0VGFnOwogIHZhciBwcm90b3R5cGVGb3JUYWcgPSBob29rcy5wcm90b3R5cGVGb3JU
+YWc7CiAgZnVuY3Rpb24gZ2V0VGFnRml4ZWQobykgewogICAgdmFyIHRhZyA9IGdldFRhZyhvKTsKICAg
+IGlmICh0YWcgPT0gIkRvY3VtZW50IikgewogICAgICBpZiAoISFvLnhtbFZlcnNpb24pIHJldHVybiAi
+IURvY3VtZW50IjsKICAgICAgcmV0dXJuICIhSFRNTERvY3VtZW50IjsKICAgIH0KICAgIHJldHVybiB0
+YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0ZpeGVkKHRhZykgewogICAgaWYgKHRhZyA9
+PSAiRG9jdW1lbnQiKSByZXR1cm4gbnVsbDsKICAgIHJldHVybiBwcm90b3R5cGVGb3JUYWcodGFnKTsK
+ICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRml4ZWQ7CiAgaG9va3MucHJvdG90eXBlRm9yVGFnID0g
+cHJvdG90eXBlRm9yVGFnRml4ZWQ7Cn0KQy5kaz1mdW5jdGlvbihob29rcykgewogIHZhciB1c2VyQWdl
+bnQgPSB0eXBlb2YgbmF2aWdhdG9yID09ICJvYmplY3QiID8gbmF2aWdhdG9yLnVzZXJBZ2VudCA6ICIi
+OwogIGlmICh1c2VyQWdlbnQuaW5kZXhPZigiRmlyZWZveCIpID09IC0xKSByZXR1cm4gaG9va3M7CiAg
+dmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAgICAiQmVmb3JlVW5s
+b2FkRXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9hcmQiLAogICAgIkdl
+b0dlb2xvY2F0aW9uIjogIkdlb2xvY2F0aW9uIiwKICAgICJMb2NhdGlvbiI6ICIhTG9jYXRpb24iLAog
+ICAgIldvcmtlck1lc3NhZ2VFdmVudCI6ICJNZXNzYWdlRXZlbnQiLAogICAgIlhNTERvY3VtZW50Ijog
+IiFEb2N1bWVudCJ9OwogIGZ1bmN0aW9uIGdldFRhZ0ZpcmVmb3gobykgewogICAgdmFyIHRhZyA9IGdl
+dFRhZyhvKTsKICAgIHJldHVybiBxdWlja01hcFt0YWddIHx8IHRhZzsKICB9CiAgaG9va3MuZ2V0VGFn
+ID0gZ2V0VGFnRmlyZWZveDsKfQpDLnhpPWZ1bmN0aW9uKGhvb2tzKSB7CiAgdmFyIHVzZXJBZ2VudCA9
+IHR5cGVvZiBuYXZpZ2F0b3IgPT0gIm9iamVjdCIgPyBuYXZpZ2F0b3IudXNlckFnZW50IDogIiI7CiAg
+aWYgKHVzZXJBZ2VudC5pbmRleE9mKCJUcmlkZW50LyIpID09IC0xKSByZXR1cm4gaG9va3M7CiAgdmFy
+IGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAgICAiQmVmb3JlVW5sb2Fk
+RXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9hcmQiLAogICAgIkhUTUxE
+REVsZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIkhUTUxEVEVsZW1lbnQiOiAiSFRNTEVsZW1lbnQi
+LAogICAgIkhUTUxQaHJhc2VFbGVtZW50IjogIkhUTUxFbGVtZW50IiwKICAgICJQb3NpdGlvbiI6ICJH
+ZW9wb3NpdGlvbiIKICB9OwogIGZ1bmN0aW9uIGdldFRhZ0lFKG8pIHsKICAgIHZhciB0YWcgPSBnZXRU
+YWcobyk7CiAgICB2YXIgbmV3VGFnID0gcXVpY2tNYXBbdGFnXTsKICAgIGlmIChuZXdUYWcpIHJldHVy
+biBuZXdUYWc7CiAgICBpZiAodGFnID09ICJPYmplY3QiKSB7CiAgICAgIGlmICh3aW5kb3cuRGF0YVZp
+ZXcgJiYgKG8gaW5zdGFuY2VvZiB3aW5kb3cuRGF0YVZpZXcpKSByZXR1cm4gIkRhdGFWaWV3IjsKICAg
+IH0KICAgIHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0lFKHRhZykgewog
+ICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBpZiAoY29uc3RydWN0b3IgPT0gbnVs
+bCkgcmV0dXJuIG51bGw7CiAgICByZXR1cm4gY29uc3RydWN0b3IucHJvdG90eXBlOwogIH0KICBob29r
+cy5nZXRUYWcgPSBnZXRUYWdJRTsKICBob29rcy5wcm90b3R5cGVGb3JUYWcgPSBwcm90b3R5cGVGb3JU
+YWdJRTsKfQpDLmk3PWZ1bmN0aW9uKGhvb2tzKSB7IHJldHVybiBob29rczsgfQoKQy5DdD1uZXcgUC5i
+eSgpCkMuRXE9bmV3IFAuazUoKQpDLnhNPW5ldyBQLnU1KCkKQy5Raz1uZXcgUC5FMygpCkMuTnY9bmV3
+IEgua3IoKQpDLk5VPW5ldyBQLkppKCkKQy5wZD1uZXcgUC5aZCgpCkMuQWQ9bmV3IFIuSDcoMCwiSGlu
+dEFjdGlvbktpbmQuYWRkTnVsbGFibGVIaW50IikKQy5uZT1uZXcgUi5INygxLCJIaW50QWN0aW9uS2lu
+ZC5hZGROb25OdWxsYWJsZUhpbnQiKQpDLm15PW5ldyBSLkg3KDIsIkhpbnRBY3Rpb25LaW5kLmNoYW5n
+ZVRvTnVsbGFibGVIaW50IikKQy5yeD1uZXcgUi5INygzLCJIaW50QWN0aW9uS2luZC5jaGFuZ2VUb05v
+bk51bGxhYmxlSGludCIpCkMud1Y9bmV3IFIuSDcoNCwiSGludEFjdGlvbktpbmQucmVtb3ZlTnVsbGFi
+bGVIaW50IikKQy5mUj1uZXcgUi5INyg1LCJIaW50QWN0aW9uS2luZC5yZW1vdmVOb25OdWxsYWJsZUhp
+bnQiKQpDLkEzPW5ldyBQLk14KG51bGwpCkMublg9bmV3IFAub2oobnVsbCkKQy5jdz1uZXcgTC5HYigw
+LCJVbml0TWlncmF0aW9uU3RhdHVzLmFscmVhZHlNaWdyYXRlZCIpCkMuZGM9bmV3IEwuR2IoMSwiVW5p
+dE1pZ3JhdGlvblN0YXR1cy5pbmRldGVybWluYXRlIikKQy5XRD1uZXcgTC5HYigyLCJVbml0TWlncmF0
+aW9uU3RhdHVzLm1pZ3JhdGluZyIpCkMuWGo9bmV3IEwuR2IoMywiVW5pdE1pZ3JhdGlvblN0YXR1cy5v
+cHRpbmdPdXQiKQpDLmwwPUguVk0ocyhbQy5jdyxDLmRjLEMuV0QsQy5Yal0pLEguTjAoImpkPEdiKj4i
+KSkKQy5haz1ILlZNKHMoWzAsMCwzMjc3NiwzMzc5MiwxLDEwMjQwLDAsMF0pLHQuVikKQy5jbT1ILlZN
+KHMoWyIqOjpjbGFzcyIsIio6OmRpciIsIio6OmRyYWdnYWJsZSIsIio6OmhpZGRlbiIsIio6OmlkIiwi
+Kjo6aW5lcnQiLCIqOjppdGVtcHJvcCIsIio6Oml0ZW1yZWYiLCIqOjppdGVtc2NvcGUiLCIqOjpsYW5n
+IiwiKjo6c3BlbGxjaGVjayIsIio6OnRpdGxlIiwiKjo6dHJhbnNsYXRlIiwiQTo6YWNjZXNza2V5Iiwi
+QTo6Y29vcmRzIiwiQTo6aHJlZmxhbmciLCJBOjpuYW1lIiwiQTo6c2hhcGUiLCJBOjp0YWJpbmRleCIs
+IkE6OnRhcmdldCIsIkE6OnR5cGUiLCJBUkVBOjphY2Nlc3NrZXkiLCJBUkVBOjphbHQiLCJBUkVBOjpj
+b29yZHMiLCJBUkVBOjpub2hyZWYiLCJBUkVBOjpzaGFwZSIsIkFSRUE6OnRhYmluZGV4IiwiQVJFQTo6
+dGFyZ2V0IiwiQVVESU86OmNvbnRyb2xzIiwiQVVESU86Omxvb3AiLCJBVURJTzo6bWVkaWFncm91cCIs
+IkFVRElPOjptdXRlZCIsIkFVRElPOjpwcmVsb2FkIiwiQkRPOjpkaXIiLCJCT0RZOjphbGluayIsIkJP
+RFk6OmJnY29sb3IiLCJCT0RZOjpsaW5rIiwiQk9EWTo6dGV4dCIsIkJPRFk6OnZsaW5rIiwiQlI6OmNs
+ZWFyIiwiQlVUVE9OOjphY2Nlc3NrZXkiLCJCVVRUT046OmRpc2FibGVkIiwiQlVUVE9OOjpuYW1lIiwi
+QlVUVE9OOjp0YWJpbmRleCIsIkJVVFRPTjo6dHlwZSIsIkJVVFRPTjo6dmFsdWUiLCJDQU5WQVM6Omhl
+aWdodCIsIkNBTlZBUzo6d2lkdGgiLCJDQVBUSU9OOjphbGlnbiIsIkNPTDo6YWxpZ24iLCJDT0w6OmNo
+YXIiLCJDT0w6OmNoYXJvZmYiLCJDT0w6OnNwYW4iLCJDT0w6OnZhbGlnbiIsIkNPTDo6d2lkdGgiLCJD
+T0xHUk9VUDo6YWxpZ24iLCJDT0xHUk9VUDo6Y2hhciIsIkNPTEdST1VQOjpjaGFyb2ZmIiwiQ09MR1JP
+VVA6OnNwYW4iLCJDT0xHUk9VUDo6dmFsaWduIiwiQ09MR1JPVVA6OndpZHRoIiwiQ09NTUFORDo6Y2hl
+Y2tlZCIsIkNPTU1BTkQ6OmNvbW1hbmQiLCJDT01NQU5EOjpkaXNhYmxlZCIsIkNPTU1BTkQ6OmxhYmVs
+IiwiQ09NTUFORDo6cmFkaW9ncm91cCIsIkNPTU1BTkQ6OnR5cGUiLCJEQVRBOjp2YWx1ZSIsIkRFTDo6
+ZGF0ZXRpbWUiLCJERVRBSUxTOjpvcGVuIiwiRElSOjpjb21wYWN0IiwiRElWOjphbGlnbiIsIkRMOjpj
+b21wYWN0IiwiRklFTERTRVQ6OmRpc2FibGVkIiwiRk9OVDo6Y29sb3IiLCJGT05UOjpmYWNlIiwiRk9O
+VDo6c2l6ZSIsIkZPUk06OmFjY2VwdCIsIkZPUk06OmF1dG9jb21wbGV0ZSIsIkZPUk06OmVuY3R5cGUi
+LCJGT1JNOjptZXRob2QiLCJGT1JNOjpuYW1lIiwiRk9STTo6bm92YWxpZGF0ZSIsIkZPUk06OnRhcmdl
+dCIsIkZSQU1FOjpuYW1lIiwiSDE6OmFsaWduIiwiSDI6OmFsaWduIiwiSDM6OmFsaWduIiwiSDQ6OmFs
+aWduIiwiSDU6OmFsaWduIiwiSDY6OmFsaWduIiwiSFI6OmFsaWduIiwiSFI6Om5vc2hhZGUiLCJIUjo6
+c2l6ZSIsIkhSOjp3aWR0aCIsIkhUTUw6OnZlcnNpb24iLCJJRlJBTUU6OmFsaWduIiwiSUZSQU1FOjpm
+cmFtZWJvcmRlciIsIklGUkFNRTo6aGVpZ2h0IiwiSUZSQU1FOjptYXJnaW5oZWlnaHQiLCJJRlJBTUU6
+Om1hcmdpbndpZHRoIiwiSUZSQU1FOjp3aWR0aCIsIklNRzo6YWxpZ24iLCJJTUc6OmFsdCIsIklNRzo6
+Ym9yZGVyIiwiSU1HOjpoZWlnaHQiLCJJTUc6OmhzcGFjZSIsIklNRzo6aXNtYXAiLCJJTUc6Om5hbWUi
+LCJJTUc6OnVzZW1hcCIsIklNRzo6dnNwYWNlIiwiSU1HOjp3aWR0aCIsIklOUFVUOjphY2NlcHQiLCJJ
+TlBVVDo6YWNjZXNza2V5IiwiSU5QVVQ6OmFsaWduIiwiSU5QVVQ6OmFsdCIsIklOUFVUOjphdXRvY29t
+cGxldGUiLCJJTlBVVDo6YXV0b2ZvY3VzIiwiSU5QVVQ6OmNoZWNrZWQiLCJJTlBVVDo6ZGlzYWJsZWQi
+LCJJTlBVVDo6aW5wdXRtb2RlIiwiSU5QVVQ6OmlzbWFwIiwiSU5QVVQ6Omxpc3QiLCJJTlBVVDo6bWF4
+IiwiSU5QVVQ6Om1heGxlbmd0aCIsIklOUFVUOjptaW4iLCJJTlBVVDo6bXVsdGlwbGUiLCJJTlBVVDo6
+bmFtZSIsIklOUFVUOjpwbGFjZWhvbGRlciIsIklOUFVUOjpyZWFkb25seSIsIklOUFVUOjpyZXF1aXJl
+ZCIsIklOUFVUOjpzaXplIiwiSU5QVVQ6OnN0ZXAiLCJJTlBVVDo6dGFiaW5kZXgiLCJJTlBVVDo6dHlw
+ZSIsIklOUFVUOjp1c2VtYXAiLCJJTlBVVDo6dmFsdWUiLCJJTlM6OmRhdGV0aW1lIiwiS0VZR0VOOjpk
+aXNhYmxlZCIsIktFWUdFTjo6a2V5dHlwZSIsIktFWUdFTjo6bmFtZSIsIkxBQkVMOjphY2Nlc3NrZXki
+LCJMQUJFTDo6Zm9yIiwiTEVHRU5EOjphY2Nlc3NrZXkiLCJMRUdFTkQ6OmFsaWduIiwiTEk6OnR5cGUi
+LCJMSTo6dmFsdWUiLCJMSU5LOjpzaXplcyIsIk1BUDo6bmFtZSIsIk1FTlU6OmNvbXBhY3QiLCJNRU5V
+OjpsYWJlbCIsIk1FTlU6OnR5cGUiLCJNRVRFUjo6aGlnaCIsIk1FVEVSOjpsb3ciLCJNRVRFUjo6bWF4
+IiwiTUVURVI6Om1pbiIsIk1FVEVSOjp2YWx1ZSIsIk9CSkVDVDo6dHlwZW11c3RtYXRjaCIsIk9MOjpj
+b21wYWN0IiwiT0w6OnJldmVyc2VkIiwiT0w6OnN0YXJ0IiwiT0w6OnR5cGUiLCJPUFRHUk9VUDo6ZGlz
+YWJsZWQiLCJPUFRHUk9VUDo6bGFiZWwiLCJPUFRJT046OmRpc2FibGVkIiwiT1BUSU9OOjpsYWJlbCIs
+Ik9QVElPTjo6c2VsZWN0ZWQiLCJPUFRJT046OnZhbHVlIiwiT1VUUFVUOjpmb3IiLCJPVVRQVVQ6Om5h
+bWUiLCJQOjphbGlnbiIsIlBSRTo6d2lkdGgiLCJQUk9HUkVTUzo6bWF4IiwiUFJPR1JFU1M6Om1pbiIs
+IlBST0dSRVNTOjp2YWx1ZSIsIlNFTEVDVDo6YXV0b2NvbXBsZXRlIiwiU0VMRUNUOjpkaXNhYmxlZCIs
+IlNFTEVDVDo6bXVsdGlwbGUiLCJTRUxFQ1Q6Om5hbWUiLCJTRUxFQ1Q6OnJlcXVpcmVkIiwiU0VMRUNU
+OjpzaXplIiwiU0VMRUNUOjp0YWJpbmRleCIsIlNPVVJDRTo6dHlwZSIsIlRBQkxFOjphbGlnbiIsIlRB
+QkxFOjpiZ2NvbG9yIiwiVEFCTEU6OmJvcmRlciIsIlRBQkxFOjpjZWxscGFkZGluZyIsIlRBQkxFOjpj
+ZWxsc3BhY2luZyIsIlRBQkxFOjpmcmFtZSIsIlRBQkxFOjpydWxlcyIsIlRBQkxFOjpzdW1tYXJ5Iiwi
+VEFCTEU6OndpZHRoIiwiVEJPRFk6OmFsaWduIiwiVEJPRFk6OmNoYXIiLCJUQk9EWTo6Y2hhcm9mZiIs
+IlRCT0RZOjp2YWxpZ24iLCJURDo6YWJiciIsIlREOjphbGlnbiIsIlREOjpheGlzIiwiVEQ6OmJnY29s
+b3IiLCJURDo6Y2hhciIsIlREOjpjaGFyb2ZmIiwiVEQ6OmNvbHNwYW4iLCJURDo6aGVhZGVycyIsIlRE
+OjpoZWlnaHQiLCJURDo6bm93cmFwIiwiVEQ6OnJvd3NwYW4iLCJURDo6c2NvcGUiLCJURDo6dmFsaWdu
+IiwiVEQ6OndpZHRoIiwiVEVYVEFSRUE6OmFjY2Vzc2tleSIsIlRFWFRBUkVBOjphdXRvY29tcGxldGUi
+LCJURVhUQVJFQTo6Y29scyIsIlRFWFRBUkVBOjpkaXNhYmxlZCIsIlRFWFRBUkVBOjppbnB1dG1vZGUi
+LCJURVhUQVJFQTo6bmFtZSIsIlRFWFRBUkVBOjpwbGFjZWhvbGRlciIsIlRFWFRBUkVBOjpyZWFkb25s
+eSIsIlRFWFRBUkVBOjpyZXF1aXJlZCIsIlRFWFRBUkVBOjpyb3dzIiwiVEVYVEFSRUE6OnRhYmluZGV4
+IiwiVEVYVEFSRUE6OndyYXAiLCJURk9PVDo6YWxpZ24iLCJURk9PVDo6Y2hhciIsIlRGT09UOjpjaGFy
+b2ZmIiwiVEZPT1Q6OnZhbGlnbiIsIlRIOjphYmJyIiwiVEg6OmFsaWduIiwiVEg6OmF4aXMiLCJUSDo6
+Ymdjb2xvciIsIlRIOjpjaGFyIiwiVEg6OmNoYXJvZmYiLCJUSDo6Y29sc3BhbiIsIlRIOjpoZWFkZXJz
+IiwiVEg6OmhlaWdodCIsIlRIOjpub3dyYXAiLCJUSDo6cm93c3BhbiIsIlRIOjpzY29wZSIsIlRIOjp2
+YWxpZ24iLCJUSDo6d2lkdGgiLCJUSEVBRDo6YWxpZ24iLCJUSEVBRDo6Y2hhciIsIlRIRUFEOjpjaGFy
+b2ZmIiwiVEhFQUQ6OnZhbGlnbiIsIlRSOjphbGlnbiIsIlRSOjpiZ2NvbG9yIiwiVFI6OmNoYXIiLCJU
+Ujo6Y2hhcm9mZiIsIlRSOjp2YWxpZ24iLCJUUkFDSzo6ZGVmYXVsdCIsIlRSQUNLOjpraW5kIiwiVFJB
+Q0s6OmxhYmVsIiwiVFJBQ0s6OnNyY2xhbmciLCJVTDo6Y29tcGFjdCIsIlVMOjp0eXBlIiwiVklERU86
+OmNvbnRyb2xzIiwiVklERU86OmhlaWdodCIsIlZJREVPOjpsb29wIiwiVklERU86Om1lZGlhZ3JvdXAi
+LCJWSURFTzo6bXV0ZWQiLCJWSURFTzo6cHJlbG9hZCIsIlZJREVPOjp3aWR0aCJdKSx0LmkpCkMuVkM9
+SC5WTShzKFswLDAsNjU0OTAsNDUwNTUsNjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMubUs9
+SC5WTShzKFswLDAsMjY2MjQsMTAyMyw2NTUzNCwyMDQ3LDY1NTM0LDIwNDddKSx0LlYpCkMuU3E9SC5W
+TShzKFsiSEVBRCIsIkFSRUEiLCJCQVNFIiwiQkFTRUZPTlQiLCJCUiIsIkNPTCIsIkNPTEdST1VQIiwi
+RU1CRUQiLCJGUkFNRSIsIkZSQU1FU0VUIiwiSFIiLCJJTUFHRSIsIklNRyIsIklOUFVUIiwiSVNJTkRF
+WCIsIkxJTksiLCJNRVRBIiwiUEFSQU0iLCJTT1VSQ0UiLCJTVFlMRSIsIlRJVExFIiwiV0JSIl0pLHQu
+aSkKQy5oVT1ILlZNKHMoW10pLHQuYikKQy5kbj1ILlZNKHMoW10pLEguTjAoImpkPExMKj4iKSkKQy54
+RD1ILlZNKHMoW10pLHQuaSkKQy50bz1ILlZNKHMoWzAsMCwzMjcyMiwxMjI4Nyw2NTUzNCwzNDgxNSw2
+NTUzNCwxODQzMV0pLHQuVikKQy5yaz1ILlZNKHMoW0MuQWQsQy5uZSxDLm15LEMucngsQy53VixDLmZS
+XSksSC5OMCgiamQ8SDcqPiIpKQpDLkYzPUguVk0ocyhbMCwwLDI0NTc2LDEwMjMsNjU1MzQsMzQ4MTUs
+NjU1MzQsMTg0MzFdKSx0LlYpCkMuZWE9SC5WTShzKFswLDAsMzI3NTQsMTEyNjMsNjU1MzQsMzQ4MTUs
+NjU1MzQsMTg0MzFdKSx0LlYpCkMuWko9SC5WTShzKFswLDAsMzI3MjIsMTIyODcsNjU1MzUsMzQ4MTUs
+NjU1MzQsMTg0MzFdKSx0LlYpCkMuV2Q9SC5WTShzKFswLDAsNjU0OTAsMTIyODcsNjU1MzUsMzQ4MTUs
+NjU1MzQsMTg0MzFdKSx0LlYpCkMuUXg9SC5WTShzKFsiYmluZCIsImlmIiwicmVmIiwicmVwZWF0Iiwi
+c3ludGF4Il0pLHQuaSkKQy5CST1ILlZNKHMoWyJBOjpocmVmIiwiQVJFQTo6aHJlZiIsIkJMT0NLUVVP
+VEU6OmNpdGUiLCJCT0RZOjpiYWNrZ3JvdW5kIiwiQ09NTUFORDo6aWNvbiIsIkRFTDo6Y2l0ZSIsIkZP
+Uk06OmFjdGlvbiIsIklNRzo6c3JjIiwiSU5QVVQ6OnNyYyIsIklOUzo6Y2l0ZSIsIlE6OmNpdGUiLCJW
+SURFTzo6cG9zdGVyIl0pLHQuaSkKQy5EeD1uZXcgSC5MUCgwLHt9LEMueEQsSC5OMCgiTFA8cVUqLHpN
+PGo4Kj4qPiIpKQpDLkNNPW5ldyBILkxQKDAse30sQy54RCxILk4wKCJMUDxxVSoscVUqPiIpKQpDLmlI
+PUguVk0ocyhbXSksSC5OMCgiamQ8R0QqPiIpKQpDLldPPW5ldyBILkxQKDAse30sQy5pSCxILk4wKCJM
+UDxHRCosQD4iKSkKQy5ZMj1uZXcgTC5POSgiTmF2aWdhdGlvblRyZWVOb2RlVHlwZS5kaXJlY3Rvcnki
+KQpDLnJmPW5ldyBMLk85KCJOYXZpZ2F0aW9uVHJlZU5vZGVUeXBlLmZpbGUiKQpDLlRlPW5ldyBILnd2
+KCJjYWxsIikKQy5vRT1uZXcgUC5HWSghMSkKQy53UT1uZXcgUC5GeShudWxsLDIpfSkoKTsoZnVuY3Rp
+b24gc3RhdGljRmllbGRzKCl7JC56bT1udWxsCiQueWo9MAokLm1KPW51bGwKJC5QND1udWxsCiQuTkY9
+bnVsbAokLlRYPW51bGwKJC54Nz1udWxsCiQubnc9bnVsbAokLnZ2PW51bGwKJC5Cdj1udWxsCiQuUzY9
+bnVsbAokLms4PW51bGwKJC5tZz1udWxsCiQuVUQ9ITEKJC5YMz1DLk5VCiQueGc9SC5WTShbXSxILk4w
+KCJqZDxNaD4iKSkKJC54bz1udWxsCiQuQk89bnVsbAokLmx0PW51bGwKJC5FVT1udWxsCiQub3I9UC5G
+bCh0Lk4sdC5ZKQokLklSPW51bGwKJC5JNj1udWxsCiQuRmY9bnVsbH0pKCk7KGZ1bmN0aW9uIGxhenlJ
+bml0aWFsaXplcnMoKXt2YXIgcz1odW5rSGVscGVycy5sYXp5RmluYWwscj1odW5rSGVscGVycy5sYXp5
+T2xkCnMoJCwiZmEiLCJ3IixmdW5jdGlvbigpe3JldHVybiBILllnKCJfJGRhcnRfZGFydENsb3N1cmUi
+KX0pCnMoJCwiVTIiLCJTbiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHsKdG9TdHJpbmc6ZnVu
+Y3Rpb24oKXtyZXR1cm4iJHJlY2VpdmVyJCJ9fSkpfSkKcygkLCJ4cSIsImxxIixmdW5jdGlvbigpe3Jl
+dHVybiBILmNNKEguUzcoeyRtZXRob2QkOm51bGwsCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIiRy
+ZWNlaXZlciQifX0pKX0pCnMoJCwiUjEiLCJOOSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KG51
+bGwpKX0pCnMoJCwiZk4iLCJpSSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3ZhciAk
+YXJndW1lbnRzRXhwciQ9IiRhcmd1bWVudHMkIgp0cnl7bnVsbC4kbWV0aG9kJCgkYXJndW1lbnRzRXhw
+ciQpfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwicWkiLCJVTiIsZnVuY3Rpb24o
+KXtyZXR1cm4gSC5jTShILlM3KHZvaWQgMCkpfSkKcygkLCJyWiIsIlpoIixmdW5jdGlvbigpe3JldHVy
+biBILmNNKGZ1bmN0aW9uKCl7dmFyICRhcmd1bWVudHNFeHByJD0iJGFyZ3VtZW50cyQiCnRyeXsodm9p
+ZCAwKS4kbWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgp
+KX0pCnMoJCwia3EiLCJyTiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILk1qKG51bGwpKX0pCnMoJCwi
+dHQiLCJjMyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3RyeXtudWxsLiRtZXRob2Qk
+fWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwiZHQiLCJISyIsZnVuY3Rpb24oKXty
+ZXR1cm4gSC5jTShILk1qKHZvaWQgMCkpfSkKcygkLCJBNyIsInIxIixmdW5jdGlvbigpe3JldHVybiBI
+LmNNKGZ1bmN0aW9uKCl7dHJ5eyh2b2lkIDApLiRtZXRob2QkfWNhdGNoKHEpe3JldHVybiBxLm1lc3Nh
+Z2V9fSgpKX0pCnMoJCwiV2MiLCJ1dCIsZnVuY3Rpb24oKXtyZXR1cm4gUC5PaigpfSkKcygkLCJraCIs
+InJmIixmdW5jdGlvbigpe3JldHVybiBuZXcgUC54cigpLiQwKCl9KQpzKCQsImRIIiwiSEciLGZ1bmN0
+aW9uKCl7cmV0dXJuIG5ldyBQLk56KCkuJDAoKX0pCnMoJCwiYnQiLCJWNyIsZnVuY3Rpb24oKXtyZXR1
+cm4gbmV3IEludDhBcnJheShILlhGKEguVk0oWy0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0y
LC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0y
-LC0yLC0yLC0yLC0yLC0xLC0yLC0yLC0yLC0yLC0yLDYyLC0yLDYyLC0yLDYzLDUyLDUzLDU0LDU1LDU2
-LDU3LDU4LDU5LDYwLDYxLC0yLC0yLC0yLC0xLC0yLC0yLC0yLDAsMSwyLDMsNCw1LDYsNyw4LDksMTAs
-MTEsMTIsMTMsMTQsMTUsMTYsMTcsMTgsMTksMjAsMjEsMjIsMjMsMjQsMjUsLTIsLTIsLTIsLTIsNjMs
-LTIsMjYsMjcsMjgsMjksMzAsMzEsMzIsMzMsMzQsMzUsMzYsMzcsMzgsMzksNDAsNDEsNDIsNDMsNDQs
-NDUsNDYsNDcsNDgsNDksNTAsNTEsLTIsLTIsLTIsLTIsLTJdLHQuYSkpKX0pCnMoJCwiTTUiLCJ3USIs
-ZnVuY3Rpb24oKXtyZXR1cm4gdHlwZW9mIHByb2Nlc3MhPSJ1bmRlZmluZWQiJiZPYmplY3QucHJvdG90
-eXBlLnRvU3RyaW5nLmNhbGwocHJvY2Vzcyk9PSJbb2JqZWN0IHByb2Nlc3NdIiYmcHJvY2Vzcy5wbGF0
-Zm9ybT09IndpbjMyIn0pCnMoJCwibWYiLCJ6NCIsZnVuY3Rpb24oKXtyZXR1cm4gUC5udSgiXltcXC1c
-XC4wLTlBLVpfYS16fl0qJCIpfSkKcygkLCJPUSIsInZaIixmdW5jdGlvbigpe3JldHVybiBQLktOKCl9
-KQpzKCQsIlNDIiwiQU4iLGZ1bmN0aW9uKCl7cmV0dXJuIFAudE0oWyJBIiwiQUJCUiIsIkFDUk9OWU0i
-LCJBRERSRVNTIiwiQVJFQSIsIkFSVElDTEUiLCJBU0lERSIsIkFVRElPIiwiQiIsIkJESSIsIkJETyIs
-IkJJRyIsIkJMT0NLUVVPVEUiLCJCUiIsIkJVVFRPTiIsIkNBTlZBUyIsIkNBUFRJT04iLCJDRU5URVIi
-LCJDSVRFIiwiQ09ERSIsIkNPTCIsIkNPTEdST1VQIiwiQ09NTUFORCIsIkRBVEEiLCJEQVRBTElTVCIs
-IkREIiwiREVMIiwiREVUQUlMUyIsIkRGTiIsIkRJUiIsIkRJViIsIkRMIiwiRFQiLCJFTSIsIkZJRUxE
-U0VUIiwiRklHQ0FQVElPTiIsIkZJR1VSRSIsIkZPTlQiLCJGT09URVIiLCJGT1JNIiwiSDEiLCJIMiIs
-IkgzIiwiSDQiLCJINSIsIkg2IiwiSEVBREVSIiwiSEdST1VQIiwiSFIiLCJJIiwiSUZSQU1FIiwiSU1H
-IiwiSU5QVVQiLCJJTlMiLCJLQkQiLCJMQUJFTCIsIkxFR0VORCIsIkxJIiwiTUFQIiwiTUFSSyIsIk1F
-TlUiLCJNRVRFUiIsIk5BViIsIk5PQlIiLCJPTCIsIk9QVEdST1VQIiwiT1BUSU9OIiwiT1VUUFVUIiwi
-UCIsIlBSRSIsIlBST0dSRVNTIiwiUSIsIlMiLCJTQU1QIiwiU0VDVElPTiIsIlNFTEVDVCIsIlNNQUxM
-IiwiU09VUkNFIiwiU1BBTiIsIlNUUklLRSIsIlNUUk9ORyIsIlNVQiIsIlNVTU1BUlkiLCJTVVAiLCJU
-QUJMRSIsIlRCT0RZIiwiVEQiLCJURVhUQVJFQSIsIlRGT09UIiwiVEgiLCJUSEVBRCIsIlRJTUUiLCJU
-UiIsIlRSQUNLIiwiVFQiLCJVIiwiVUwiLCJWQVIiLCJWSURFTyIsIldCUiJdLHQuTil9KQpzKCQsIlg0
-IiwiaEciLGZ1bmN0aW9uKCl7cmV0dXJuIFAubnUoIl5cXFMrJCIpfSkKcygkLCJ3TyIsIm93IixmdW5j
-dGlvbigpe3JldHVybiBQLk5EKHNlbGYpfSkKcygkLCJrdCIsIlI4IixmdW5jdGlvbigpe3JldHVybiBI
-LllnKCJfJGRhcnRfZGFydE9iamVjdCIpfSkKcygkLCJmSyIsImtJIixmdW5jdGlvbigpe3JldHVybiBm
-dW5jdGlvbiBEYXJ0T2JqZWN0KGEpe3RoaXMubz1hfX0pCnIoJCwicXQiLCJ6QiIsZnVuY3Rpb24oKXty
-ZXR1cm4gbmV3IFQubVEoKX0pCnIoJCwiT2wiLCJVRSIsZnVuY3Rpb24oKXtyZXR1cm4gUC5oSyhDLm9s
-LmdtVyhXLngzKCkpLmhyZWYpLmdoWSgpLnEoMCwiYXV0aFRva2VuIil9KQpyKCQsImhUIiwieVAiLGZ1
-bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIuZWRpdC1saXN0IC5wYW5lbC1jb250
-ZW50Iil9KQpyKCQsIlc2IiwiaEwiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9y
-KCIuZWRpdC1wYW5lbCAucGFuZWwtY29udGVudCIpfSkKcigkLCJUUiIsIkRXIixmdW5jdGlvbigpe3Jl
-dHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiZm9vdGVyIil9KQpyKCQsIkVZIiwiZmkiLGZ1bmN0aW9u
-KCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCJoZWFkZXIiKX0pCnIoJCwiYXYiLCJEOSIsZnVu
-Y3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiN1bml0LW5hbWUiKX0pCnIoJCwidDAi
-LCJiTiIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRlLXVuaXQt
-c3RhdHVzLWljb24tbGFiZWwiKX0pCnIoJCwiYkEiLCJjMCIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigp
-LnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24iKX0pCnIoJCwiZmUiLCJLRyIs
-ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEwuWEEoKX0pCnMoJCwiZW8iLCJuVSIsZnVuY3Rpb24oKXtyZXR1
-cm4gbmV3IE0ubEkoJC5IaygpKX0pCnMoJCwieXIiLCJiRCIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEUu
-T0YoUC5udSgiLyIpLFAubnUoIlteL10kIiksUC5udSgiXi8iKSl9KQpzKCQsIk1rIiwiS2siLGZ1bmN0
-aW9uKCl7cmV0dXJuIG5ldyBMLklWKFAubnUoIlsvXFxcXF0iKSxQLm51KCJbXi9cXFxcXSQiKSxQLm51
-KCJeKFxcXFxcXFxcW15cXFxcXStcXFxcW15cXFxcL10rfFthLXpBLVpdOlsvXFxcXF0pIiksUC5udSgi
-XlsvXFxcXF0oPyFbL1xcXFxdKSIpKX0pCnMoJCwiYWsiLCJFYiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3
-IEYucnUoUC5udSgiLyIpLFAubnUoIiheW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly98W14vXSkkIiks
-UC5udSgiW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly9bXi9dKiIpLFAubnUoIl4vIikpfSkKcygkLCJs
-cyIsIkhrIixmdW5jdGlvbigpe3JldHVybiBPLlJoKCl9KX0pKCk7KGZ1bmN0aW9uIG5hdGl2ZVN1cHBv
-cnQoKXshZnVuY3Rpb24oKXt2YXIgcz1mdW5jdGlvbihhKXt2YXIgbT17fQptW2FdPTEKcmV0dXJuIE9i
-amVjdC5rZXlzKGh1bmtIZWxwZXJzLmNvbnZlcnRUb0Zhc3RPYmplY3QobSkpWzBdfQp2LmdldElzb2xh
-dGVUYWc9ZnVuY3Rpb24oYSl7cmV0dXJuIHMoIl9fX2RhcnRfIithK3YuaXNvbGF0ZVRhZyl9CnZhciBy
-PSJfX19kYXJ0X2lzb2xhdGVfdGFnc18iCnZhciBxPU9iamVjdFtyXXx8KE9iamVjdFtyXT1PYmplY3Qu
-Y3JlYXRlKG51bGwpKQp2YXIgcD0iX1p4WXhYIgpmb3IodmFyIG89MDs7bysrKXt2YXIgbj1zKHArIl8i
-K28rIl8iKQppZighKG4gaW4gcSkpe3Fbbl09MQp2Lmlzb2xhdGVUYWc9bgpicmVha319di5kaXNwYXRj
-aFByb3BlcnR5TmFtZT12LmdldElzb2xhdGVUYWcoImRpc3BhdGNoX3JlY29yZCIpfSgpCmh1bmtIZWxw
-ZXJzLnNldE9yVXBkYXRlSW50ZXJjZXB0b3JzQnlUYWcoe0RPTUVycm9yOkouR3YsTWVkaWFFcnJvcjpK
-Lkd2LE5hdmlnYXRvcjpKLkd2LE5hdmlnYXRvckNvbmN1cnJlbnRIYXJkd2FyZTpKLkd2LE5hdmlnYXRv
-clVzZXJNZWRpYUVycm9yOkouR3YsT3ZlcmNvbnN0cmFpbmVkRXJyb3I6Si5HdixQb3NpdGlvbkVycm9y
-OkouR3YsUmFuZ2U6Si5HdixTUUxFcnJvcjpKLkd2LERhdGFWaWV3OkguRVQsQXJyYXlCdWZmZXJWaWV3
-OkguRVQsRmxvYXQzMkFycmF5OkguRGcsRmxvYXQ2NEFycmF5OkguRGcsSW50MTZBcnJheTpILnhqLElu
-dDMyQXJyYXk6SC5kRSxJbnQ4QXJyYXk6SC5aQSxVaW50MTZBcnJheTpILmRULFVpbnQzMkFycmF5Okgu
-UHEsVWludDhDbGFtcGVkQXJyYXk6SC5lRSxDYW52YXNQaXhlbEFycmF5OkguZUUsVWludDhBcnJheTpI
-LlY2LEhUTUxBdWRpb0VsZW1lbnQ6Vy5xRSxIVE1MQlJFbGVtZW50OlcucUUsSFRNTEJ1dHRvbkVsZW1l
-bnQ6Vy5xRSxIVE1MQ2FudmFzRWxlbWVudDpXLnFFLEhUTUxDb250ZW50RWxlbWVudDpXLnFFLEhUTUxE
-TGlzdEVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUxpc3RFbGVtZW50Olcu
-cUUsSFRNTERldGFpbHNFbGVtZW50OlcucUUsSFRNTERpYWxvZ0VsZW1lbnQ6Vy5xRSxIVE1MRGl2RWxl
-bWVudDpXLnFFLEhUTUxFbWJlZEVsZW1lbnQ6Vy5xRSxIVE1MRmllbGRTZXRFbGVtZW50OlcucUUsSFRN
-TEhSRWxlbWVudDpXLnFFLEhUTUxIZWFkRWxlbWVudDpXLnFFLEhUTUxIZWFkaW5nRWxlbWVudDpXLnFF
-LEhUTUxIdG1sRWxlbWVudDpXLnFFLEhUTUxJRnJhbWVFbGVtZW50OlcucUUsSFRNTEltYWdlRWxlbWVu
-dDpXLnFFLEhUTUxJbnB1dEVsZW1lbnQ6Vy5xRSxIVE1MTElFbGVtZW50OlcucUUsSFRNTExhYmVsRWxl
-bWVudDpXLnFFLEhUTUxMZWdlbmRFbGVtZW50OlcucUUsSFRNTExpbmtFbGVtZW50OlcucUUsSFRNTE1h
-cEVsZW1lbnQ6Vy5xRSxIVE1MTWVkaWFFbGVtZW50OlcucUUsSFRNTE1lbnVFbGVtZW50OlcucUUsSFRN
-TE1ldGFFbGVtZW50OlcucUUsSFRNTE1ldGVyRWxlbWVudDpXLnFFLEhUTUxNb2RFbGVtZW50OlcucUUs
-SFRNTE9MaXN0RWxlbWVudDpXLnFFLEhUTUxPYmplY3RFbGVtZW50OlcucUUsSFRNTE9wdEdyb3VwRWxl
-bWVudDpXLnFFLEhUTUxPcHRpb25FbGVtZW50OlcucUUsSFRNTE91dHB1dEVsZW1lbnQ6Vy5xRSxIVE1M
-UGFyYW1FbGVtZW50OlcucUUsSFRNTFBpY3R1cmVFbGVtZW50OlcucUUsSFRNTFByZUVsZW1lbnQ6Vy5x
-RSxIVE1MUHJvZ3Jlc3NFbGVtZW50OlcucUUsSFRNTFF1b3RlRWxlbWVudDpXLnFFLEhUTUxTY3JpcHRF
-bGVtZW50OlcucUUsSFRNTFNoYWRvd0VsZW1lbnQ6Vy5xRSxIVE1MU2xvdEVsZW1lbnQ6Vy5xRSxIVE1M
-U291cmNlRWxlbWVudDpXLnFFLEhUTUxTcGFuRWxlbWVudDpXLnFFLEhUTUxTdHlsZUVsZW1lbnQ6Vy5x
-RSxIVE1MVGFibGVDYXB0aW9uRWxlbWVudDpXLnFFLEhUTUxUYWJsZUNlbGxFbGVtZW50OlcucUUsSFRN
-TFRhYmxlRGF0YUNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlSGVhZGVyQ2VsbEVsZW1lbnQ6Vy5xRSxI
-VE1MVGFibGVDb2xFbGVtZW50OlcucUUsSFRNTFRleHRBcmVhRWxlbWVudDpXLnFFLEhUTUxUaW1lRWxl
-bWVudDpXLnFFLEhUTUxUaXRsZUVsZW1lbnQ6Vy5xRSxIVE1MVHJhY2tFbGVtZW50OlcucUUsSFRNTFVM
-aXN0RWxlbWVudDpXLnFFLEhUTUxVbmtub3duRWxlbWVudDpXLnFFLEhUTUxWaWRlb0VsZW1lbnQ6Vy5x
-RSxIVE1MRGlyZWN0b3J5RWxlbWVudDpXLnFFLEhUTUxGb250RWxlbWVudDpXLnFFLEhUTUxGcmFtZUVs
-ZW1lbnQ6Vy5xRSxIVE1MRnJhbWVTZXRFbGVtZW50OlcucUUsSFRNTE1hcnF1ZWVFbGVtZW50OlcucUUs
-SFRNTEVsZW1lbnQ6Vy5xRSxIVE1MQW5jaG9yRWxlbWVudDpXLkdoLEhUTUxBcmVhRWxlbWVudDpXLmZZ
-LEhUTUxCYXNlRWxlbWVudDpXLm5CLEJsb2I6Vy5BeixIVE1MQm9keUVsZW1lbnQ6Vy5RUCxDREFUQVNl
-Y3Rpb246Vy5ueCxDaGFyYWN0ZXJEYXRhOlcubngsQ29tbWVudDpXLm54LFByb2Nlc3NpbmdJbnN0cnVj
-dGlvbjpXLm54LFRleHQ6Vy5ueCxDU1NTdHlsZURlY2xhcmF0aW9uOlcub0osTVNTdHlsZUNTU1Byb3Bl
-cnRpZXM6Vy5vSixDU1MyUHJvcGVydGllczpXLm9KLFhNTERvY3VtZW50OlcuUUYsRG9jdW1lbnQ6Vy5R
-RixET01FeGNlcHRpb246Vy5OaCxET01JbXBsZW1lbnRhdGlvbjpXLmFlLERPTVJlY3RSZWFkT25seTpX
-LklCLERPTVRva2VuTGlzdDpXLm43LEVsZW1lbnQ6Vy5jdixBYm9ydFBheW1lbnRFdmVudDpXLmVhLEFu
-aW1hdGlvbkV2ZW50OlcuZWEsQW5pbWF0aW9uUGxheWJhY2tFdmVudDpXLmVhLEFwcGxpY2F0aW9uQ2Fj
-aGVFcnJvckV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVudDpXLmVhLEJhY2tncm91bmRG
-ZXRjaEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNo
-ZWRFdmVudDpXLmVhLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDpXLmVhLEJlZm9yZVVubG9hZEV2ZW50
-OlcuZWEsQmxvYkV2ZW50OlcuZWEsQ2FuTWFrZVBheW1lbnRFdmVudDpXLmVhLENsaXBib2FyZEV2ZW50
-OlcuZWEsQ2xvc2VFdmVudDpXLmVhLEN1c3RvbUV2ZW50OlcuZWEsRGV2aWNlTW90aW9uRXZlbnQ6Vy5l
-YSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OlcuZWEsRXJyb3JFdmVudDpXLmVhLEV4dGVuZGFibGVFdmVu
-dDpXLmVhLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6Vy5lYSxGZXRjaEV2ZW50OlcuZWEsRm9udEZhY2VT
-ZXRMb2FkRXZlbnQ6Vy5lYSxGb3JlaWduRmV0Y2hFdmVudDpXLmVhLEdhbWVwYWRFdmVudDpXLmVhLEhh
-c2hDaGFuZ2VFdmVudDpXLmVhLEluc3RhbGxFdmVudDpXLmVhLE1lZGlhRW5jcnlwdGVkRXZlbnQ6Vy5l
-YSxNZWRpYUtleU1lc3NhZ2VFdmVudDpXLmVhLE1lZGlhUXVlcnlMaXN0RXZlbnQ6Vy5lYSxNZWRpYVN0
-cmVhbUV2ZW50OlcuZWEsTWVkaWFTdHJlYW1UcmFja0V2ZW50OlcuZWEsTWVzc2FnZUV2ZW50OlcuZWEs
-TUlESUNvbm5lY3Rpb25FdmVudDpXLmVhLE1JRElNZXNzYWdlRXZlbnQ6Vy5lYSxNdXRhdGlvbkV2ZW50
-OlcuZWEsTm90aWZpY2F0aW9uRXZlbnQ6Vy5lYSxQYWdlVHJhbnNpdGlvbkV2ZW50OlcuZWEsUGF5bWVu
-dFJlcXVlc3RFdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZlbnQ6Vy5lYSxQb3BTdGF0ZUV2
-ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2ZW50OlcuZWEsUHJlc2VudGF0
-aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6Vy5lYSxQcm9taXNlUmVqZWN0aW9uRXZlbnQ6Vy5lYSxQdXNo
-RXZlbnQ6Vy5lYSxSVENEYXRhQ2hhbm5lbEV2ZW50OlcuZWEsUlRDRFRNRlRvbmVDaGFuZ2VFdmVudDpX
-LmVhLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6Vy5lYSxSVENUcmFja0V2ZW50OlcuZWEsU2VjdXJp
-dHlQb2xpY3lWaW9sYXRpb25FdmVudDpXLmVhLFNlbnNvckVycm9yRXZlbnQ6Vy5lYSxTcGVlY2hSZWNv
-Z25pdGlvbkVycm9yOlcuZWEsU3BlZWNoUmVjb2duaXRpb25FdmVudDpXLmVhLFNwZWVjaFN5bnRoZXNp
-c0V2ZW50OlcuZWEsU3RvcmFnZUV2ZW50OlcuZWEsU3luY0V2ZW50OlcuZWEsVHJhY2tFdmVudDpXLmVh
-LFRyYW5zaXRpb25FdmVudDpXLmVhLFdlYktpdFRyYW5zaXRpb25FdmVudDpXLmVhLFZSRGV2aWNlRXZl
-bnQ6Vy5lYSxWUkRpc3BsYXlFdmVudDpXLmVhLFZSU2Vzc2lvbkV2ZW50OlcuZWEsTW9qb0ludGVyZmFj
-ZVJlcXVlc3RFdmVudDpXLmVhLFVTQkNvbm5lY3Rpb25FdmVudDpXLmVhLElEQlZlcnNpb25DaGFuZ2VF
-dmVudDpXLmVhLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OlcuZWEsT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2
-ZW50OlcuZWEsV2ViR0xDb250ZXh0RXZlbnQ6Vy5lYSxFdmVudDpXLmVhLElucHV0RXZlbnQ6Vy5lYSxT
-dWJtaXRFdmVudDpXLmVhLEV2ZW50VGFyZ2V0OlcuRDAsRmlsZTpXLmhILEhUTUxGb3JtRWxlbWVudDpX
-Lmg0LEhpc3Rvcnk6Vy5icixIVE1MRG9jdW1lbnQ6Vy5WYixYTUxIdHRwUmVxdWVzdDpXLmZKLFhNTEh0
-dHBSZXF1ZXN0RXZlbnRUYXJnZXQ6Vy53YSxJbWFnZURhdGE6Vy5TZyxMb2NhdGlvbjpXLnc3LE1vdXNl
-RXZlbnQ6Vy5BaixEcmFnRXZlbnQ6Vy5BaixQb2ludGVyRXZlbnQ6Vy5BaixXaGVlbEV2ZW50OlcuQWos
-RG9jdW1lbnRGcmFnbWVudDpXLnVILFNoYWRvd1Jvb3Q6Vy51SCxEb2N1bWVudFR5cGU6Vy51SCxOb2Rl
-OlcudUgsTm9kZUxpc3Q6Vy5CSCxSYWRpb05vZGVMaXN0OlcuQkgsSFRNTFBhcmFncmFwaEVsZW1lbnQ6
-Vy5TTixQcm9ncmVzc0V2ZW50OlcuZXcsUmVzb3VyY2VQcm9ncmVzc0V2ZW50OlcuZXcsSFRNTFNlbGVj
-dEVsZW1lbnQ6Vy5scCxIVE1MVGFibGVFbGVtZW50OlcuVGIsSFRNTFRhYmxlUm93RWxlbWVudDpXLkl2
-LEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OlcuV1AsSFRNTFRlbXBsYXRlRWxlbWVudDpXLnlZLENvbXBv
-c2l0aW9uRXZlbnQ6Vy53NixGb2N1c0V2ZW50OlcudzYsS2V5Ym9hcmRFdmVudDpXLnc2LFRleHRFdmVu
-dDpXLnc2LFRvdWNoRXZlbnQ6Vy53NixVSUV2ZW50OlcudzYsV2luZG93OlcuSzUsRE9NV2luZG93Olcu
-SzUsRGVkaWNhdGVkV29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxTZXJ2aWNlV29ya2VyR2xvYmFsU2NvcGU6
-Vy5DbSxTaGFyZWRXb3JrZXJHbG9iYWxTY29wZTpXLkNtLFdvcmtlckdsb2JhbFNjb3BlOlcuQ20sQXR0
-cjpXLkNRLENsaWVudFJlY3Q6Vy53NCxET01SZWN0OlcudzQsTmFtZWROb2RlTWFwOlcucmgsTW96TmFt
-ZWRBdHRyTWFwOlcucmgsSURCS2V5UmFuZ2U6UC5oRixTVkdTY3JpcHRFbGVtZW50OlAubmQsU1ZHQUVs
-ZW1lbnQ6UC5oaSxTVkdBbmltYXRlRWxlbWVudDpQLmhpLFNWR0FuaW1hdGVNb3Rpb25FbGVtZW50OlAu
-aGksU1ZHQW5pbWF0ZVRyYW5zZm9ybUVsZW1lbnQ6UC5oaSxTVkdBbmltYXRpb25FbGVtZW50OlAuaGks
-U1ZHQ2lyY2xlRWxlbWVudDpQLmhpLFNWR0NsaXBQYXRoRWxlbWVudDpQLmhpLFNWR0RlZnNFbGVtZW50
-OlAuaGksU1ZHRGVzY0VsZW1lbnQ6UC5oaSxTVkdEaXNjYXJkRWxlbWVudDpQLmhpLFNWR0VsbGlwc2VF
-bGVtZW50OlAuaGksU1ZHRkVCbGVuZEVsZW1lbnQ6UC5oaSxTVkdGRUNvbG9yTWF0cml4RWxlbWVudDpQ
-LmhpLFNWR0ZFQ29tcG9uZW50VHJhbnNmZXJFbGVtZW50OlAuaGksU1ZHRkVDb21wb3NpdGVFbGVtZW50
-OlAuaGksU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQ6UC5oaSxTVkdGRURpZmZ1c2VMaWdodGluZ0Vs
-ZW1lbnQ6UC5oaSxTVkdGRURpc3BsYWNlbWVudE1hcEVsZW1lbnQ6UC5oaSxTVkdGRURpc3RhbnRMaWdo
-dEVsZW1lbnQ6UC5oaSxTVkdGRUZsb29kRWxlbWVudDpQLmhpLFNWR0ZFRnVuY0FFbGVtZW50OlAuaGks
-U1ZHRkVGdW5jQkVsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNHRWxlbWVudDpQLmhpLFNWR0ZFRnVuY1JFbGVt
-ZW50OlAuaGksU1ZHRkVHYXVzc2lhbkJsdXJFbGVtZW50OlAuaGksU1ZHRkVJbWFnZUVsZW1lbnQ6UC5o
-aSxTVkdGRU1lcmdlRWxlbWVudDpQLmhpLFNWR0ZFTWVyZ2VOb2RlRWxlbWVudDpQLmhpLFNWR0ZFTW9y
-cGhvbG9neUVsZW1lbnQ6UC5oaSxTVkdGRU9mZnNldEVsZW1lbnQ6UC5oaSxTVkdGRVBvaW50TGlnaHRF
-bGVtZW50OlAuaGksU1ZHRkVTcGVjdWxhckxpZ2h0aW5nRWxlbWVudDpQLmhpLFNWR0ZFU3BvdExpZ2h0
-RWxlbWVudDpQLmhpLFNWR0ZFVGlsZUVsZW1lbnQ6UC5oaSxTVkdGRVR1cmJ1bGVuY2VFbGVtZW50OlAu
-aGksU1ZHRmlsdGVyRWxlbWVudDpQLmhpLFNWR0ZvcmVpZ25PYmplY3RFbGVtZW50OlAuaGksU1ZHR0Vs
-ZW1lbnQ6UC5oaSxTVkdHZW9tZXRyeUVsZW1lbnQ6UC5oaSxTVkdHcmFwaGljc0VsZW1lbnQ6UC5oaSxT
-VkdJbWFnZUVsZW1lbnQ6UC5oaSxTVkdMaW5lRWxlbWVudDpQLmhpLFNWR0xpbmVhckdyYWRpZW50RWxl
-bWVudDpQLmhpLFNWR01hcmtlckVsZW1lbnQ6UC5oaSxTVkdNYXNrRWxlbWVudDpQLmhpLFNWR01ldGFk
-YXRhRWxlbWVudDpQLmhpLFNWR1BhdGhFbGVtZW50OlAuaGksU1ZHUGF0dGVybkVsZW1lbnQ6UC5oaSxT
-VkdQb2x5Z29uRWxlbWVudDpQLmhpLFNWR1BvbHlsaW5lRWxlbWVudDpQLmhpLFNWR1JhZGlhbEdyYWRp
-ZW50RWxlbWVudDpQLmhpLFNWR1JlY3RFbGVtZW50OlAuaGksU1ZHU2V0RWxlbWVudDpQLmhpLFNWR1N0
-b3BFbGVtZW50OlAuaGksU1ZHU3R5bGVFbGVtZW50OlAuaGksU1ZHU1ZHRWxlbWVudDpQLmhpLFNWR1N3
-aXRjaEVsZW1lbnQ6UC5oaSxTVkdTeW1ib2xFbGVtZW50OlAuaGksU1ZHVFNwYW5FbGVtZW50OlAuaGks
-U1ZHVGV4dENvbnRlbnRFbGVtZW50OlAuaGksU1ZHVGV4dEVsZW1lbnQ6UC5oaSxTVkdUZXh0UGF0aEVs
-ZW1lbnQ6UC5oaSxTVkdUZXh0UG9zaXRpb25pbmdFbGVtZW50OlAuaGksU1ZHVGl0bGVFbGVtZW50OlAu
-aGksU1ZHVXNlRWxlbWVudDpQLmhpLFNWR1ZpZXdFbGVtZW50OlAuaGksU1ZHR3JhZGllbnRFbGVtZW50
-OlAuaGksU1ZHQ29tcG9uZW50VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQ6UC5oaSxTVkdGRURyb3BTaGFk
-b3dFbGVtZW50OlAuaGksU1ZHTVBhdGhFbGVtZW50OlAuaGksU1ZHRWxlbWVudDpQLmhpfSkKaHVua0hl
-bHBlcnMuc2V0T3JVcGRhdGVMZWFmVGFncyh7RE9NRXJyb3I6dHJ1ZSxNZWRpYUVycm9yOnRydWUsTmF2
-aWdhdG9yOnRydWUsTmF2aWdhdG9yQ29uY3VycmVudEhhcmR3YXJlOnRydWUsTmF2aWdhdG9yVXNlck1l
-ZGlhRXJyb3I6dHJ1ZSxPdmVyY29uc3RyYWluZWRFcnJvcjp0cnVlLFBvc2l0aW9uRXJyb3I6dHJ1ZSxS
-YW5nZTp0cnVlLFNRTEVycm9yOnRydWUsRGF0YVZpZXc6dHJ1ZSxBcnJheUJ1ZmZlclZpZXc6ZmFsc2Us
-RmxvYXQzMkFycmF5OnRydWUsRmxvYXQ2NEFycmF5OnRydWUsSW50MTZBcnJheTp0cnVlLEludDMyQXJy
-YXk6dHJ1ZSxJbnQ4QXJyYXk6dHJ1ZSxVaW50MTZBcnJheTp0cnVlLFVpbnQzMkFycmF5OnRydWUsVWlu
-dDhDbGFtcGVkQXJyYXk6dHJ1ZSxDYW52YXNQaXhlbEFycmF5OnRydWUsVWludDhBcnJheTpmYWxzZSxI
-VE1MQXVkaW9FbGVtZW50OnRydWUsSFRNTEJSRWxlbWVudDp0cnVlLEhUTUxCdXR0b25FbGVtZW50OnRy
-dWUsSFRNTENhbnZhc0VsZW1lbnQ6dHJ1ZSxIVE1MQ29udGVudEVsZW1lbnQ6dHJ1ZSxIVE1MRExpc3RF
-bGVtZW50OnRydWUsSFRNTERhdGFFbGVtZW50OnRydWUsSFRNTERhdGFMaXN0RWxlbWVudDp0cnVlLEhU
-TUxEZXRhaWxzRWxlbWVudDp0cnVlLEhUTUxEaWFsb2dFbGVtZW50OnRydWUsSFRNTERpdkVsZW1lbnQ6
-dHJ1ZSxIVE1MRW1iZWRFbGVtZW50OnRydWUsSFRNTEZpZWxkU2V0RWxlbWVudDp0cnVlLEhUTUxIUkVs
-ZW1lbnQ6dHJ1ZSxIVE1MSGVhZEVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZGluZ0VsZW1lbnQ6dHJ1ZSxIVE1M
-SHRtbEVsZW1lbnQ6dHJ1ZSxIVE1MSUZyYW1lRWxlbWVudDp0cnVlLEhUTUxJbWFnZUVsZW1lbnQ6dHJ1
-ZSxIVE1MSW5wdXRFbGVtZW50OnRydWUsSFRNTExJRWxlbWVudDp0cnVlLEhUTUxMYWJlbEVsZW1lbnQ6
-dHJ1ZSxIVE1MTGVnZW5kRWxlbWVudDp0cnVlLEhUTUxMaW5rRWxlbWVudDp0cnVlLEhUTUxNYXBFbGVt
-ZW50OnRydWUsSFRNTE1lZGlhRWxlbWVudDp0cnVlLEhUTUxNZW51RWxlbWVudDp0cnVlLEhUTUxNZXRh
-RWxlbWVudDp0cnVlLEhUTUxNZXRlckVsZW1lbnQ6dHJ1ZSxIVE1MTW9kRWxlbWVudDp0cnVlLEhUTUxP
-TGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MT2JqZWN0RWxlbWVudDp0cnVlLEhUTUxPcHRHcm91cEVsZW1lbnQ6
-dHJ1ZSxIVE1MT3B0aW9uRWxlbWVudDp0cnVlLEhUTUxPdXRwdXRFbGVtZW50OnRydWUsSFRNTFBhcmFt
-RWxlbWVudDp0cnVlLEhUTUxQaWN0dXJlRWxlbWVudDp0cnVlLEhUTUxQcmVFbGVtZW50OnRydWUsSFRN
-TFByb2dyZXNzRWxlbWVudDp0cnVlLEhUTUxRdW90ZUVsZW1lbnQ6dHJ1ZSxIVE1MU2NyaXB0RWxlbWVu
-dDp0cnVlLEhUTUxTaGFkb3dFbGVtZW50OnRydWUsSFRNTFNsb3RFbGVtZW50OnRydWUsSFRNTFNvdXJj
-ZUVsZW1lbnQ6dHJ1ZSxIVE1MU3BhbkVsZW1lbnQ6dHJ1ZSxIVE1MU3R5bGVFbGVtZW50OnRydWUsSFRN
-TFRhYmxlQ2FwdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJs
-ZURhdGFDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZUhlYWRlckNlbGxFbGVtZW50OnRydWUsSFRNTFRh
-YmxlQ29sRWxlbWVudDp0cnVlLEhUTUxUZXh0QXJlYUVsZW1lbnQ6dHJ1ZSxIVE1MVGltZUVsZW1lbnQ6
-dHJ1ZSxIVE1MVGl0bGVFbGVtZW50OnRydWUsSFRNTFRyYWNrRWxlbWVudDp0cnVlLEhUTUxVTGlzdEVs
-ZW1lbnQ6dHJ1ZSxIVE1MVW5rbm93bkVsZW1lbnQ6dHJ1ZSxIVE1MVmlkZW9FbGVtZW50OnRydWUsSFRN
-TERpcmVjdG9yeUVsZW1lbnQ6dHJ1ZSxIVE1MRm9udEVsZW1lbnQ6dHJ1ZSxIVE1MRnJhbWVFbGVtZW50
-OnRydWUsSFRNTEZyYW1lU2V0RWxlbWVudDp0cnVlLEhUTUxNYXJxdWVlRWxlbWVudDp0cnVlLEhUTUxF
-bGVtZW50OmZhbHNlLEhUTUxBbmNob3JFbGVtZW50OnRydWUsSFRNTEFyZWFFbGVtZW50OnRydWUsSFRN
-TEJhc2VFbGVtZW50OnRydWUsQmxvYjpmYWxzZSxIVE1MQm9keUVsZW1lbnQ6dHJ1ZSxDREFUQVNlY3Rp
-b246dHJ1ZSxDaGFyYWN0ZXJEYXRhOnRydWUsQ29tbWVudDp0cnVlLFByb2Nlc3NpbmdJbnN0cnVjdGlv
-bjp0cnVlLFRleHQ6dHJ1ZSxDU1NTdHlsZURlY2xhcmF0aW9uOnRydWUsTVNTdHlsZUNTU1Byb3BlcnRp
-ZXM6dHJ1ZSxDU1MyUHJvcGVydGllczp0cnVlLFhNTERvY3VtZW50OnRydWUsRG9jdW1lbnQ6ZmFsc2Us
-RE9NRXhjZXB0aW9uOnRydWUsRE9NSW1wbGVtZW50YXRpb246dHJ1ZSxET01SZWN0UmVhZE9ubHk6ZmFs
-c2UsRE9NVG9rZW5MaXN0OnRydWUsRWxlbWVudDpmYWxzZSxBYm9ydFBheW1lbnRFdmVudDp0cnVlLEFu
-aW1hdGlvbkV2ZW50OnRydWUsQW5pbWF0aW9uUGxheWJhY2tFdmVudDp0cnVlLEFwcGxpY2F0aW9uQ2Fj
-aGVFcnJvckV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVudDp0cnVlLEJhY2tncm91bmRG
-ZXRjaEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNo
-ZWRFdmVudDp0cnVlLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDp0cnVlLEJlZm9yZVVubG9hZEV2ZW50
-OnRydWUsQmxvYkV2ZW50OnRydWUsQ2FuTWFrZVBheW1lbnRFdmVudDp0cnVlLENsaXBib2FyZEV2ZW50
-OnRydWUsQ2xvc2VFdmVudDp0cnVlLEN1c3RvbUV2ZW50OnRydWUsRGV2aWNlTW90aW9uRXZlbnQ6dHJ1
-ZSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OnRydWUsRXJyb3JFdmVudDp0cnVlLEV4dGVuZGFibGVFdmVu
-dDp0cnVlLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6dHJ1ZSxGZXRjaEV2ZW50OnRydWUsRm9udEZhY2VT
-ZXRMb2FkRXZlbnQ6dHJ1ZSxGb3JlaWduRmV0Y2hFdmVudDp0cnVlLEdhbWVwYWRFdmVudDp0cnVlLEhh
-c2hDaGFuZ2VFdmVudDp0cnVlLEluc3RhbGxFdmVudDp0cnVlLE1lZGlhRW5jcnlwdGVkRXZlbnQ6dHJ1
-ZSxNZWRpYUtleU1lc3NhZ2VFdmVudDp0cnVlLE1lZGlhUXVlcnlMaXN0RXZlbnQ6dHJ1ZSxNZWRpYVN0
-cmVhbUV2ZW50OnRydWUsTWVkaWFTdHJlYW1UcmFja0V2ZW50OnRydWUsTWVzc2FnZUV2ZW50OnRydWUs
-TUlESUNvbm5lY3Rpb25FdmVudDp0cnVlLE1JRElNZXNzYWdlRXZlbnQ6dHJ1ZSxNdXRhdGlvbkV2ZW50
-OnRydWUsTm90aWZpY2F0aW9uRXZlbnQ6dHJ1ZSxQYWdlVHJhbnNpdGlvbkV2ZW50OnRydWUsUGF5bWVu
-dFJlcXVlc3RFdmVudDp0cnVlLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZlbnQ6dHJ1ZSxQb3BTdGF0ZUV2
-ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2ZW50OnRydWUsUHJlc2VudGF0
-aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6dHJ1ZSxQcm9taXNlUmVqZWN0aW9uRXZlbnQ6dHJ1ZSxQdXNo
-RXZlbnQ6dHJ1ZSxSVENEYXRhQ2hhbm5lbEV2ZW50OnRydWUsUlRDRFRNRlRvbmVDaGFuZ2VFdmVudDp0
-cnVlLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6dHJ1ZSxSVENUcmFja0V2ZW50OnRydWUsU2VjdXJp
-dHlQb2xpY3lWaW9sYXRpb25FdmVudDp0cnVlLFNlbnNvckVycm9yRXZlbnQ6dHJ1ZSxTcGVlY2hSZWNv
-Z25pdGlvbkVycm9yOnRydWUsU3BlZWNoUmVjb2duaXRpb25FdmVudDp0cnVlLFNwZWVjaFN5bnRoZXNp
-c0V2ZW50OnRydWUsU3RvcmFnZUV2ZW50OnRydWUsU3luY0V2ZW50OnRydWUsVHJhY2tFdmVudDp0cnVl
-LFRyYW5zaXRpb25FdmVudDp0cnVlLFdlYktpdFRyYW5zaXRpb25FdmVudDp0cnVlLFZSRGV2aWNlRXZl
-bnQ6dHJ1ZSxWUkRpc3BsYXlFdmVudDp0cnVlLFZSU2Vzc2lvbkV2ZW50OnRydWUsTW9qb0ludGVyZmFj
-ZVJlcXVlc3RFdmVudDp0cnVlLFVTQkNvbm5lY3Rpb25FdmVudDp0cnVlLElEQlZlcnNpb25DaGFuZ2VF
-dmVudDp0cnVlLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OnRydWUsT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2
-ZW50OnRydWUsV2ViR0xDb250ZXh0RXZlbnQ6dHJ1ZSxFdmVudDpmYWxzZSxJbnB1dEV2ZW50OmZhbHNl
-LFN1Ym1pdEV2ZW50OmZhbHNlLEV2ZW50VGFyZ2V0OmZhbHNlLEZpbGU6dHJ1ZSxIVE1MRm9ybUVsZW1l
-bnQ6dHJ1ZSxIaXN0b3J5OnRydWUsSFRNTERvY3VtZW50OnRydWUsWE1MSHR0cFJlcXVlc3Q6dHJ1ZSxY
-TUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0OmZhbHNlLEltYWdlRGF0YTp0cnVlLExvY2F0aW9uOnRydWUs
-TW91c2VFdmVudDp0cnVlLERyYWdFdmVudDp0cnVlLFBvaW50ZXJFdmVudDp0cnVlLFdoZWVsRXZlbnQ6
-dHJ1ZSxEb2N1bWVudEZyYWdtZW50OnRydWUsU2hhZG93Um9vdDp0cnVlLERvY3VtZW50VHlwZTp0cnVl
-LE5vZGU6ZmFsc2UsTm9kZUxpc3Q6dHJ1ZSxSYWRpb05vZGVMaXN0OnRydWUsSFRNTFBhcmFncmFwaEVs
-ZW1lbnQ6dHJ1ZSxQcm9ncmVzc0V2ZW50OnRydWUsUmVzb3VyY2VQcm9ncmVzc0V2ZW50OnRydWUsSFRN
-TFNlbGVjdEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVFbGVtZW50OnRydWUsSFRNTFRhYmxlUm93RWxlbWVu
-dDp0cnVlLEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OnRydWUsSFRNTFRlbXBsYXRlRWxlbWVudDp0cnVl
-LENvbXBvc2l0aW9uRXZlbnQ6dHJ1ZSxGb2N1c0V2ZW50OnRydWUsS2V5Ym9hcmRFdmVudDp0cnVlLFRl
-eHRFdmVudDp0cnVlLFRvdWNoRXZlbnQ6dHJ1ZSxVSUV2ZW50OmZhbHNlLFdpbmRvdzp0cnVlLERPTVdp
-bmRvdzp0cnVlLERlZGljYXRlZFdvcmtlckdsb2JhbFNjb3BlOnRydWUsU2VydmljZVdvcmtlckdsb2Jh
-bFNjb3BlOnRydWUsU2hhcmVkV29ya2VyR2xvYmFsU2NvcGU6dHJ1ZSxXb3JrZXJHbG9iYWxTY29wZTp0
-cnVlLEF0dHI6dHJ1ZSxDbGllbnRSZWN0OnRydWUsRE9NUmVjdDp0cnVlLE5hbWVkTm9kZU1hcDp0cnVl
-LE1vek5hbWVkQXR0ck1hcDp0cnVlLElEQktleVJhbmdlOnRydWUsU1ZHU2NyaXB0RWxlbWVudDp0cnVl
-LFNWR0FFbGVtZW50OnRydWUsU1ZHQW5pbWF0ZUVsZW1lbnQ6dHJ1ZSxTVkdBbmltYXRlTW90aW9uRWxl
-bWVudDp0cnVlLFNWR0FuaW1hdGVUcmFuc2Zvcm1FbGVtZW50OnRydWUsU1ZHQW5pbWF0aW9uRWxlbWVu
-dDp0cnVlLFNWR0NpcmNsZUVsZW1lbnQ6dHJ1ZSxTVkdDbGlwUGF0aEVsZW1lbnQ6dHJ1ZSxTVkdEZWZz
-RWxlbWVudDp0cnVlLFNWR0Rlc2NFbGVtZW50OnRydWUsU1ZHRGlzY2FyZEVsZW1lbnQ6dHJ1ZSxTVkdF
-bGxpcHNlRWxlbWVudDp0cnVlLFNWR0ZFQmxlbmRFbGVtZW50OnRydWUsU1ZHRkVDb2xvck1hdHJpeEVs
-ZW1lbnQ6dHJ1ZSxTVkdGRUNvbXBvbmVudFRyYW5zZmVyRWxlbWVudDp0cnVlLFNWR0ZFQ29tcG9zaXRl
-RWxlbWVudDp0cnVlLFNWR0ZFQ29udm9sdmVNYXRyaXhFbGVtZW50OnRydWUsU1ZHRkVEaWZmdXNlTGln
-aHRpbmdFbGVtZW50OnRydWUsU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50OnRydWUsU1ZHRkVEaXN0
-YW50TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVGbG9vZEVsZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNBRWxlbWVu
-dDp0cnVlLFNWR0ZFRnVuY0JFbGVtZW50OnRydWUsU1ZHRkVGdW5jR0VsZW1lbnQ6dHJ1ZSxTVkdGRUZ1
-bmNSRWxlbWVudDp0cnVlLFNWR0ZFR2F1c3NpYW5CbHVyRWxlbWVudDp0cnVlLFNWR0ZFSW1hZ2VFbGVt
-ZW50OnRydWUsU1ZHRkVNZXJnZUVsZW1lbnQ6dHJ1ZSxTVkdGRU1lcmdlTm9kZUVsZW1lbnQ6dHJ1ZSxT
-VkdGRU1vcnBob2xvZ3lFbGVtZW50OnRydWUsU1ZHRkVPZmZzZXRFbGVtZW50OnRydWUsU1ZHRkVQb2lu
-dExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFU3BlY3VsYXJMaWdodGluZ0VsZW1lbnQ6dHJ1ZSxTVkdGRVNw
-b3RMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVRpbGVFbGVtZW50OnRydWUsU1ZHRkVUdXJidWxlbmNlRWxl
-bWVudDp0cnVlLFNWR0ZpbHRlckVsZW1lbnQ6dHJ1ZSxTVkdGb3JlaWduT2JqZWN0RWxlbWVudDp0cnVl
-LFNWR0dFbGVtZW50OnRydWUsU1ZHR2VvbWV0cnlFbGVtZW50OnRydWUsU1ZHR3JhcGhpY3NFbGVtZW50
-OnRydWUsU1ZHSW1hZ2VFbGVtZW50OnRydWUsU1ZHTGluZUVsZW1lbnQ6dHJ1ZSxTVkdMaW5lYXJHcmFk
-aWVudEVsZW1lbnQ6dHJ1ZSxTVkdNYXJrZXJFbGVtZW50OnRydWUsU1ZHTWFza0VsZW1lbnQ6dHJ1ZSxT
-VkdNZXRhZGF0YUVsZW1lbnQ6dHJ1ZSxTVkdQYXRoRWxlbWVudDp0cnVlLFNWR1BhdHRlcm5FbGVtZW50
-OnRydWUsU1ZHUG9seWdvbkVsZW1lbnQ6dHJ1ZSxTVkdQb2x5bGluZUVsZW1lbnQ6dHJ1ZSxTVkdSYWRp
-YWxHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdSZWN0RWxlbWVudDp0cnVlLFNWR1NldEVsZW1lbnQ6dHJ1
-ZSxTVkdTdG9wRWxlbWVudDp0cnVlLFNWR1N0eWxlRWxlbWVudDp0cnVlLFNWR1NWR0VsZW1lbnQ6dHJ1
-ZSxTVkdTd2l0Y2hFbGVtZW50OnRydWUsU1ZHU3ltYm9sRWxlbWVudDp0cnVlLFNWR1RTcGFuRWxlbWVu
-dDp0cnVlLFNWR1RleHRDb250ZW50RWxlbWVudDp0cnVlLFNWR1RleHRFbGVtZW50OnRydWUsU1ZHVGV4
-dFBhdGhFbGVtZW50OnRydWUsU1ZHVGV4dFBvc2l0aW9uaW5nRWxlbWVudDp0cnVlLFNWR1RpdGxlRWxl
-bWVudDp0cnVlLFNWR1VzZUVsZW1lbnQ6dHJ1ZSxTVkdWaWV3RWxlbWVudDp0cnVlLFNWR0dyYWRpZW50
-RWxlbWVudDp0cnVlLFNWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50OnRydWUsU1ZHRkVE
-cm9wU2hhZG93RWxlbWVudDp0cnVlLFNWR01QYXRoRWxlbWVudDp0cnVlLFNWR0VsZW1lbnQ6ZmFsc2V9
-KQpILkxaLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguUkcuJG5hdGl2ZVN1
-cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5WUC4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJy
-YXlCdWZmZXJWaWV3IgpILkRnLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkgu
-V0IuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5aRy4kbmF0aXZlU3VwZXJj
-bGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILlBnLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1
-ZmZlclZpZXcifSkoKQpjb252ZXJ0QWxsVG9GYXN0T2JqZWN0KHcpCmNvbnZlcnRUb0Zhc3RPYmplY3Qo
-JCk7KGZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBkb2N1bWVudD09PSJ1bmRlZmluZWQiKXthKG51bGwpCnJl
-dHVybn1pZih0eXBlb2YgZG9jdW1lbnQuY3VycmVudFNjcmlwdCE9InVuZGVmaW5lZCIpe2EoZG9jdW1l
-bnQuY3VycmVudFNjcmlwdCkKcmV0dXJufXZhciBzPWRvY3VtZW50LnNjcmlwdHMKZnVuY3Rpb24gb25M
-b2FkKGIpe2Zvcih2YXIgcT0wO3E8cy5sZW5ndGg7KytxKXNbcV0ucmVtb3ZlRXZlbnRMaXN0ZW5lcigi
-bG9hZCIsb25Mb2FkLGZhbHNlKQphKGIudGFyZ2V0KX1mb3IodmFyIHI9MDtyPHMubGVuZ3RoOysrcilz
-W3JdLmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLG9uTG9hZCxmYWxzZSl9KShmdW5jdGlvbihhKXt2LmN1
-cnJlbnRTY3JpcHQ9YQp2YXIgcz1MLklxCmlmKHR5cGVvZiBkYXJ0TWFpblJ1bm5lcj09PSJmdW5jdGlv
-biIpZGFydE1haW5SdW5uZXIocyxbXSkKZWxzZSBzKFtdKX0pfSkoKQovLyMgc291cmNlTWFwcGluZ1VS
-TD1taWdyYXRpb24uanMubWFwCg==
+LC0yLC0yLC0yLC0yLC0yLC0yLC0xLC0yLC0yLC0yLC0yLC0yLDYyLC0yLDYyLC0yLDYzLDUyLDUzLDU0
+LDU1LDU2LDU3LDU4LDU5LDYwLDYxLC0yLC0yLC0yLC0xLC0yLC0yLC0yLDAsMSwyLDMsNCw1LDYsNyw4
+LDksMTAsMTEsMTIsMTMsMTQsMTUsMTYsMTcsMTgsMTksMjAsMjEsMjIsMjMsMjQsMjUsLTIsLTIsLTIs
+LTIsNjMsLTIsMjYsMjcsMjgsMjksMzAsMzEsMzIsMzMsMzQsMzUsMzYsMzcsMzgsMzksNDAsNDEsNDIs
+NDMsNDQsNDUsNDYsNDcsNDgsNDksNTAsNTEsLTIsLTIsLTIsLTIsLTJdLHQuYSkpKX0pCnMoJCwiTTUi
+LCJ3USIsZnVuY3Rpb24oKXtyZXR1cm4gdHlwZW9mIHByb2Nlc3MhPSJ1bmRlZmluZWQiJiZPYmplY3Qu
+cHJvdG90eXBlLnRvU3RyaW5nLmNhbGwocHJvY2Vzcyk9PSJbb2JqZWN0IHByb2Nlc3NdIiYmcHJvY2Vz
+cy5wbGF0Zm9ybT09IndpbjMyIn0pCnMoJCwibWYiLCJ6NCIsZnVuY3Rpb24oKXtyZXR1cm4gUC5udSgi
+XltcXC1cXC4wLTlBLVpfYS16fl0qJCIpfSkKcygkLCJPUSIsInZaIixmdW5jdGlvbigpe3JldHVybiBQ
+LktOKCl9KQpzKCQsIlNDIiwiQU4iLGZ1bmN0aW9uKCl7cmV0dXJuIFAudE0oWyJBIiwiQUJCUiIsIkFD
+Uk9OWU0iLCJBRERSRVNTIiwiQVJFQSIsIkFSVElDTEUiLCJBU0lERSIsIkFVRElPIiwiQiIsIkJESSIs
+IkJETyIsIkJJRyIsIkJMT0NLUVVPVEUiLCJCUiIsIkJVVFRPTiIsIkNBTlZBUyIsIkNBUFRJT04iLCJD
+RU5URVIiLCJDSVRFIiwiQ09ERSIsIkNPTCIsIkNPTEdST1VQIiwiQ09NTUFORCIsIkRBVEEiLCJEQVRB
+TElTVCIsIkREIiwiREVMIiwiREVUQUlMUyIsIkRGTiIsIkRJUiIsIkRJViIsIkRMIiwiRFQiLCJFTSIs
+IkZJRUxEU0VUIiwiRklHQ0FQVElPTiIsIkZJR1VSRSIsIkZPTlQiLCJGT09URVIiLCJGT1JNIiwiSDEi
+LCJIMiIsIkgzIiwiSDQiLCJINSIsIkg2IiwiSEVBREVSIiwiSEdST1VQIiwiSFIiLCJJIiwiSUZSQU1F
+IiwiSU1HIiwiSU5QVVQiLCJJTlMiLCJLQkQiLCJMQUJFTCIsIkxFR0VORCIsIkxJIiwiTUFQIiwiTUFS
+SyIsIk1FTlUiLCJNRVRFUiIsIk5BViIsIk5PQlIiLCJPTCIsIk9QVEdST1VQIiwiT1BUSU9OIiwiT1VU
+UFVUIiwiUCIsIlBSRSIsIlBST0dSRVNTIiwiUSIsIlMiLCJTQU1QIiwiU0VDVElPTiIsIlNFTEVDVCIs
+IlNNQUxMIiwiU09VUkNFIiwiU1BBTiIsIlNUUklLRSIsIlNUUk9ORyIsIlNVQiIsIlNVTU1BUlkiLCJT
+VVAiLCJUQUJMRSIsIlRCT0RZIiwiVEQiLCJURVhUQVJFQSIsIlRGT09UIiwiVEgiLCJUSEVBRCIsIlRJ
+TUUiLCJUUiIsIlRSQUNLIiwiVFQiLCJVIiwiVUwiLCJWQVIiLCJWSURFTyIsIldCUiJdLHQuTil9KQpz
+KCQsIlg0IiwiaEciLGZ1bmN0aW9uKCl7cmV0dXJuIFAubnUoIl5cXFMrJCIpfSkKcygkLCJ3TyIsIm93
+IixmdW5jdGlvbigpe3JldHVybiBQLk5EKHNlbGYpfSkKcygkLCJrdCIsIlI4IixmdW5jdGlvbigpe3Jl
+dHVybiBILllnKCJfJGRhcnRfZGFydE9iamVjdCIpfSkKcygkLCJmSyIsImtJIixmdW5jdGlvbigpe3Jl
+dHVybiBmdW5jdGlvbiBEYXJ0T2JqZWN0KGEpe3RoaXMubz1hfX0pCnIoJCwicXQiLCJ6QiIsZnVuY3Rp
+b24oKXtyZXR1cm4gbmV3IFQubVEoKX0pCnIoJCwiT2wiLCJVRSIsZnVuY3Rpb24oKXtyZXR1cm4gUC5o
+SyhDLm9sLmdtVyhXLngzKCkpLmhyZWYpLmdoWSgpLnEoMCwiYXV0aFRva2VuIil9KQpyKCQsImhUIiwi
+eVAiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIuZWRpdC1saXN0IC5wYW5l
+bC1jb250ZW50Iil9KQpyKCQsIlc2IiwiaEwiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNl
+bGVjdG9yKCIuZWRpdC1wYW5lbCAucGFuZWwtY29udGVudCIpfSkKcigkLCJUUiIsIkRXIixmdW5jdGlv
+bigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiZm9vdGVyIil9KQpyKCQsIkVZIiwiZmkiLGZ1
+bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCJoZWFkZXIiKX0pCnIoJCwiYXYiLCJE
+OSIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiN1bml0LW5hbWUiKX0pCnIo
+JCwidDAiLCJiTiIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRl
+LXVuaXQtc3RhdHVzLWljb24tbGFiZWwiKX0pCnIoJCwiYkEiLCJjMCIsZnVuY3Rpb24oKXtyZXR1cm4g
+Vy5acigpLnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24iKX0pCnIoJCwiZmUi
+LCJLRyIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEwuWEEoKX0pCnMoJCwiZW8iLCJuVSIsZnVuY3Rpb24o
+KXtyZXR1cm4gbmV3IE0ubEkoJC5IaygpKX0pCnMoJCwieXIiLCJiRCIsZnVuY3Rpb24oKXtyZXR1cm4g
+bmV3IEUuT0YoUC5udSgiLyIpLFAubnUoIlteL10kIiksUC5udSgiXi8iKSl9KQpzKCQsIk1rIiwiS2si
+LGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBMLklWKFAubnUoIlsvXFxcXF0iKSxQLm51KCJbXi9cXFxcXSQi
+KSxQLm51KCJeKFxcXFxcXFxcW15cXFxcXStcXFxcW15cXFxcL10rfFthLXpBLVpdOlsvXFxcXF0pIiks
+UC5udSgiXlsvXFxcXF0oPyFbL1xcXFxdKSIpKX0pCnMoJCwiYWsiLCJFYiIsZnVuY3Rpb24oKXtyZXR1
+cm4gbmV3IEYucnUoUC5udSgiLyIpLFAubnUoIiheW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly98W14v
+XSkkIiksUC5udSgiW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly9bXi9dKiIpLFAubnUoIl4vIikpfSkK
+cygkLCJscyIsIkhrIixmdW5jdGlvbigpe3JldHVybiBPLlJoKCl9KX0pKCk7KGZ1bmN0aW9uIG5hdGl2
+ZVN1cHBvcnQoKXshZnVuY3Rpb24oKXt2YXIgcz1mdW5jdGlvbihhKXt2YXIgbT17fQptW2FdPTEKcmV0
+dXJuIE9iamVjdC5rZXlzKGh1bmtIZWxwZXJzLmNvbnZlcnRUb0Zhc3RPYmplY3QobSkpWzBdfQp2Lmdl
+dElzb2xhdGVUYWc9ZnVuY3Rpb24oYSl7cmV0dXJuIHMoIl9fX2RhcnRfIithK3YuaXNvbGF0ZVRhZyl9
+CnZhciByPSJfX19kYXJ0X2lzb2xhdGVfdGFnc18iCnZhciBxPU9iamVjdFtyXXx8KE9iamVjdFtyXT1P
+YmplY3QuY3JlYXRlKG51bGwpKQp2YXIgcD0iX1p4WXhYIgpmb3IodmFyIG89MDs7bysrKXt2YXIgbj1z
+KHArIl8iK28rIl8iKQppZighKG4gaW4gcSkpe3Fbbl09MQp2Lmlzb2xhdGVUYWc9bgpicmVha319di5k
+aXNwYXRjaFByb3BlcnR5TmFtZT12LmdldElzb2xhdGVUYWcoImRpc3BhdGNoX3JlY29yZCIpfSgpCmh1
+bmtIZWxwZXJzLnNldE9yVXBkYXRlSW50ZXJjZXB0b3JzQnlUYWcoe0RPTUVycm9yOkouR3YsTWVkaWFF
+cnJvcjpKLkd2LE5hdmlnYXRvcjpKLkd2LE5hdmlnYXRvckNvbmN1cnJlbnRIYXJkd2FyZTpKLkd2LE5h
+dmlnYXRvclVzZXJNZWRpYUVycm9yOkouR3YsT3ZlcmNvbnN0cmFpbmVkRXJyb3I6Si5HdixQb3NpdGlv
+bkVycm9yOkouR3YsUmFuZ2U6Si5HdixTUUxFcnJvcjpKLkd2LERhdGFWaWV3OkguRVQsQXJyYXlCdWZm
+ZXJWaWV3OkguRVQsRmxvYXQzMkFycmF5OkguRGcsRmxvYXQ2NEFycmF5OkguRGcsSW50MTZBcnJheTpI
+LnhqLEludDMyQXJyYXk6SC5kRSxJbnQ4QXJyYXk6SC5aQSxVaW50MTZBcnJheTpILmRULFVpbnQzMkFy
+cmF5OkguUHEsVWludDhDbGFtcGVkQXJyYXk6SC5lRSxDYW52YXNQaXhlbEFycmF5OkguZUUsVWludDhB
+cnJheTpILlY2LEhUTUxBdWRpb0VsZW1lbnQ6Vy5xRSxIVE1MQlJFbGVtZW50OlcucUUsSFRNTEJ1dHRv
+bkVsZW1lbnQ6Vy5xRSxIVE1MQ2FudmFzRWxlbWVudDpXLnFFLEhUTUxDb250ZW50RWxlbWVudDpXLnFF
+LEhUTUxETGlzdEVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUxpc3RFbGVt
+ZW50OlcucUUsSFRNTERldGFpbHNFbGVtZW50OlcucUUsSFRNTERpYWxvZ0VsZW1lbnQ6Vy5xRSxIVE1M
+RGl2RWxlbWVudDpXLnFFLEhUTUxFbWJlZEVsZW1lbnQ6Vy5xRSxIVE1MRmllbGRTZXRFbGVtZW50Olcu
+cUUsSFRNTEhSRWxlbWVudDpXLnFFLEhUTUxIZWFkRWxlbWVudDpXLnFFLEhUTUxIZWFkaW5nRWxlbWVu
+dDpXLnFFLEhUTUxIdG1sRWxlbWVudDpXLnFFLEhUTUxJRnJhbWVFbGVtZW50OlcucUUsSFRNTEltYWdl
+RWxlbWVudDpXLnFFLEhUTUxJbnB1dEVsZW1lbnQ6Vy5xRSxIVE1MTElFbGVtZW50OlcucUUsSFRNTExh
+YmVsRWxlbWVudDpXLnFFLEhUTUxMZWdlbmRFbGVtZW50OlcucUUsSFRNTExpbmtFbGVtZW50OlcucUUs
+SFRNTE1hcEVsZW1lbnQ6Vy5xRSxIVE1MTWVkaWFFbGVtZW50OlcucUUsSFRNTE1lbnVFbGVtZW50Olcu
+cUUsSFRNTE1ldGFFbGVtZW50OlcucUUsSFRNTE1ldGVyRWxlbWVudDpXLnFFLEhUTUxNb2RFbGVtZW50
+OlcucUUsSFRNTE9MaXN0RWxlbWVudDpXLnFFLEhUTUxPYmplY3RFbGVtZW50OlcucUUsSFRNTE9wdEdy
+b3VwRWxlbWVudDpXLnFFLEhUTUxPcHRpb25FbGVtZW50OlcucUUsSFRNTE91dHB1dEVsZW1lbnQ6Vy5x
+RSxIVE1MUGFyYW1FbGVtZW50OlcucUUsSFRNTFBpY3R1cmVFbGVtZW50OlcucUUsSFRNTFByZUVsZW1l
+bnQ6Vy5xRSxIVE1MUHJvZ3Jlc3NFbGVtZW50OlcucUUsSFRNTFF1b3RlRWxlbWVudDpXLnFFLEhUTUxT
+Y3JpcHRFbGVtZW50OlcucUUsSFRNTFNoYWRvd0VsZW1lbnQ6Vy5xRSxIVE1MU2xvdEVsZW1lbnQ6Vy5x
+RSxIVE1MU291cmNlRWxlbWVudDpXLnFFLEhUTUxTcGFuRWxlbWVudDpXLnFFLEhUTUxTdHlsZUVsZW1l
+bnQ6Vy5xRSxIVE1MVGFibGVDYXB0aW9uRWxlbWVudDpXLnFFLEhUTUxUYWJsZUNlbGxFbGVtZW50Olcu
+cUUsSFRNTFRhYmxlRGF0YUNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlSGVhZGVyQ2VsbEVsZW1lbnQ6
+Vy5xRSxIVE1MVGFibGVDb2xFbGVtZW50OlcucUUsSFRNTFRleHRBcmVhRWxlbWVudDpXLnFFLEhUTUxU
+aW1lRWxlbWVudDpXLnFFLEhUTUxUaXRsZUVsZW1lbnQ6Vy5xRSxIVE1MVHJhY2tFbGVtZW50OlcucUUs
+SFRNTFVMaXN0RWxlbWVudDpXLnFFLEhUTUxVbmtub3duRWxlbWVudDpXLnFFLEhUTUxWaWRlb0VsZW1l
+bnQ6Vy5xRSxIVE1MRGlyZWN0b3J5RWxlbWVudDpXLnFFLEhUTUxGb250RWxlbWVudDpXLnFFLEhUTUxG
+cmFtZUVsZW1lbnQ6Vy5xRSxIVE1MRnJhbWVTZXRFbGVtZW50OlcucUUsSFRNTE1hcnF1ZWVFbGVtZW50
+OlcucUUsSFRNTEVsZW1lbnQ6Vy5xRSxIVE1MQW5jaG9yRWxlbWVudDpXLkdoLEhUTUxBcmVhRWxlbWVu
+dDpXLmZZLEhUTUxCYXNlRWxlbWVudDpXLm5CLEJsb2I6Vy5BeixIVE1MQm9keUVsZW1lbnQ6Vy5RUCxD
+REFUQVNlY3Rpb246Vy5ueCxDaGFyYWN0ZXJEYXRhOlcubngsQ29tbWVudDpXLm54LFByb2Nlc3NpbmdJ
+bnN0cnVjdGlvbjpXLm54LFRleHQ6Vy5ueCxDU1NTdHlsZURlY2xhcmF0aW9uOlcub0osTVNTdHlsZUNT
+U1Byb3BlcnRpZXM6Vy5vSixDU1MyUHJvcGVydGllczpXLm9KLFhNTERvY3VtZW50OlcuUUYsRG9jdW1l
+bnQ6Vy5RRixET01FeGNlcHRpb246Vy5OaCxET01JbXBsZW1lbnRhdGlvbjpXLmFlLERPTVJlY3RSZWFk
+T25seTpXLklCLERPTVRva2VuTGlzdDpXLm43LEVsZW1lbnQ6Vy5jdixBYm9ydFBheW1lbnRFdmVudDpX
+LmVhLEFuaW1hdGlvbkV2ZW50OlcuZWEsQW5pbWF0aW9uUGxheWJhY2tFdmVudDpXLmVhLEFwcGxpY2F0
+aW9uQ2FjaGVFcnJvckV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVudDpXLmVhLEJhY2tn
+cm91bmRGZXRjaEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50OlcuZWEsQmFja2dyb3Vu
+ZEZldGNoZWRFdmVudDpXLmVhLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDpXLmVhLEJlZm9yZVVubG9h
+ZEV2ZW50OlcuZWEsQmxvYkV2ZW50OlcuZWEsQ2FuTWFrZVBheW1lbnRFdmVudDpXLmVhLENsaXBib2Fy
+ZEV2ZW50OlcuZWEsQ2xvc2VFdmVudDpXLmVhLEN1c3RvbUV2ZW50OlcuZWEsRGV2aWNlTW90aW9uRXZl
+bnQ6Vy5lYSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OlcuZWEsRXJyb3JFdmVudDpXLmVhLEV4dGVuZGFi
+bGVFdmVudDpXLmVhLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6Vy5lYSxGZXRjaEV2ZW50OlcuZWEsRm9u
+dEZhY2VTZXRMb2FkRXZlbnQ6Vy5lYSxGb3JlaWduRmV0Y2hFdmVudDpXLmVhLEdhbWVwYWRFdmVudDpX
+LmVhLEhhc2hDaGFuZ2VFdmVudDpXLmVhLEluc3RhbGxFdmVudDpXLmVhLE1lZGlhRW5jcnlwdGVkRXZl
+bnQ6Vy5lYSxNZWRpYUtleU1lc3NhZ2VFdmVudDpXLmVhLE1lZGlhUXVlcnlMaXN0RXZlbnQ6Vy5lYSxN
+ZWRpYVN0cmVhbUV2ZW50OlcuZWEsTWVkaWFTdHJlYW1UcmFja0V2ZW50OlcuZWEsTWVzc2FnZUV2ZW50
+OlcuZWEsTUlESUNvbm5lY3Rpb25FdmVudDpXLmVhLE1JRElNZXNzYWdlRXZlbnQ6Vy5lYSxNdXRhdGlv
+bkV2ZW50OlcuZWEsTm90aWZpY2F0aW9uRXZlbnQ6Vy5lYSxQYWdlVHJhbnNpdGlvbkV2ZW50OlcuZWEs
+UGF5bWVudFJlcXVlc3RFdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZlbnQ6Vy5lYSxQb3BT
+dGF0ZUV2ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2ZW50OlcuZWEsUHJl
+c2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6Vy5lYSxQcm9taXNlUmVqZWN0aW9uRXZlbnQ6Vy5l
+YSxQdXNoRXZlbnQ6Vy5lYSxSVENEYXRhQ2hhbm5lbEV2ZW50OlcuZWEsUlRDRFRNRlRvbmVDaGFuZ2VF
+dmVudDpXLmVhLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6Vy5lYSxSVENUcmFja0V2ZW50OlcuZWEs
+U2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDpXLmVhLFNlbnNvckVycm9yRXZlbnQ6Vy5lYSxTcGVl
+Y2hSZWNvZ25pdGlvbkVycm9yOlcuZWEsU3BlZWNoUmVjb2duaXRpb25FdmVudDpXLmVhLFNwZWVjaFN5
+bnRoZXNpc0V2ZW50OlcuZWEsU3RvcmFnZUV2ZW50OlcuZWEsU3luY0V2ZW50OlcuZWEsVHJhY2tFdmVu
+dDpXLmVhLFRyYW5zaXRpb25FdmVudDpXLmVhLFdlYktpdFRyYW5zaXRpb25FdmVudDpXLmVhLFZSRGV2
+aWNlRXZlbnQ6Vy5lYSxWUkRpc3BsYXlFdmVudDpXLmVhLFZSU2Vzc2lvbkV2ZW50OlcuZWEsTW9qb0lu
+dGVyZmFjZVJlcXVlc3RFdmVudDpXLmVhLFVTQkNvbm5lY3Rpb25FdmVudDpXLmVhLElEQlZlcnNpb25D
+aGFuZ2VFdmVudDpXLmVhLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OlcuZWEsT2ZmbGluZUF1ZGlvQ29tcGxl
+dGlvbkV2ZW50OlcuZWEsV2ViR0xDb250ZXh0RXZlbnQ6Vy5lYSxFdmVudDpXLmVhLElucHV0RXZlbnQ6
+Vy5lYSxTdWJtaXRFdmVudDpXLmVhLEV2ZW50VGFyZ2V0OlcuRDAsRmlsZTpXLmhILEhUTUxGb3JtRWxl
+bWVudDpXLmg0LEhpc3Rvcnk6Vy5icixIVE1MRG9jdW1lbnQ6Vy5WYixYTUxIdHRwUmVxdWVzdDpXLmZK
+LFhNTEh0dHBSZXF1ZXN0RXZlbnRUYXJnZXQ6Vy53YSxJbWFnZURhdGE6Vy5TZyxMb2NhdGlvbjpXLnc3
+LE1vdXNlRXZlbnQ6Vy5BaixEcmFnRXZlbnQ6Vy5BaixQb2ludGVyRXZlbnQ6Vy5BaixXaGVlbEV2ZW50
+OlcuQWosRG9jdW1lbnRGcmFnbWVudDpXLnVILFNoYWRvd1Jvb3Q6Vy51SCxEb2N1bWVudFR5cGU6Vy51
+SCxOb2RlOlcudUgsTm9kZUxpc3Q6Vy5CSCxSYWRpb05vZGVMaXN0OlcuQkgsSFRNTFBhcmFncmFwaEVs
+ZW1lbnQ6Vy5TTixQcm9ncmVzc0V2ZW50OlcuZXcsUmVzb3VyY2VQcm9ncmVzc0V2ZW50OlcuZXcsSFRN
+TFNlbGVjdEVsZW1lbnQ6Vy5scCxIVE1MVGFibGVFbGVtZW50OlcuVGIsSFRNTFRhYmxlUm93RWxlbWVu
+dDpXLkl2LEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OlcuV1AsSFRNTFRlbXBsYXRlRWxlbWVudDpXLnlZ
+LENvbXBvc2l0aW9uRXZlbnQ6Vy53NixGb2N1c0V2ZW50OlcudzYsS2V5Ym9hcmRFdmVudDpXLnc2LFRl
+eHRFdmVudDpXLnc2LFRvdWNoRXZlbnQ6Vy53NixVSUV2ZW50OlcudzYsV2luZG93OlcuSzUsRE9NV2lu
+ZG93OlcuSzUsRGVkaWNhdGVkV29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxTZXJ2aWNlV29ya2VyR2xvYmFs
+U2NvcGU6Vy5DbSxTaGFyZWRXb3JrZXJHbG9iYWxTY29wZTpXLkNtLFdvcmtlckdsb2JhbFNjb3BlOlcu
+Q20sQXR0cjpXLkNRLENsaWVudFJlY3Q6Vy53NCxET01SZWN0OlcudzQsTmFtZWROb2RlTWFwOlcucmgs
+TW96TmFtZWRBdHRyTWFwOlcucmgsSURCS2V5UmFuZ2U6UC5oRixTVkdTY3JpcHRFbGVtZW50OlAubmQs
+U1ZHQUVsZW1lbnQ6UC5oaSxTVkdBbmltYXRlRWxlbWVudDpQLmhpLFNWR0FuaW1hdGVNb3Rpb25FbGVt
+ZW50OlAuaGksU1ZHQW5pbWF0ZVRyYW5zZm9ybUVsZW1lbnQ6UC5oaSxTVkdBbmltYXRpb25FbGVtZW50
+OlAuaGksU1ZHQ2lyY2xlRWxlbWVudDpQLmhpLFNWR0NsaXBQYXRoRWxlbWVudDpQLmhpLFNWR0RlZnNF
+bGVtZW50OlAuaGksU1ZHRGVzY0VsZW1lbnQ6UC5oaSxTVkdEaXNjYXJkRWxlbWVudDpQLmhpLFNWR0Vs
+bGlwc2VFbGVtZW50OlAuaGksU1ZHRkVCbGVuZEVsZW1lbnQ6UC5oaSxTVkdGRUNvbG9yTWF0cml4RWxl
+bWVudDpQLmhpLFNWR0ZFQ29tcG9uZW50VHJhbnNmZXJFbGVtZW50OlAuaGksU1ZHRkVDb21wb3NpdGVF
+bGVtZW50OlAuaGksU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQ6UC5oaSxTVkdGRURpZmZ1c2VMaWdo
+dGluZ0VsZW1lbnQ6UC5oaSxTVkdGRURpc3BsYWNlbWVudE1hcEVsZW1lbnQ6UC5oaSxTVkdGRURpc3Rh
+bnRMaWdodEVsZW1lbnQ6UC5oaSxTVkdGRUZsb29kRWxlbWVudDpQLmhpLFNWR0ZFRnVuY0FFbGVtZW50
+OlAuaGksU1ZHRkVGdW5jQkVsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNHRWxlbWVudDpQLmhpLFNWR0ZFRnVu
+Y1JFbGVtZW50OlAuaGksU1ZHRkVHYXVzc2lhbkJsdXJFbGVtZW50OlAuaGksU1ZHRkVJbWFnZUVsZW1l
+bnQ6UC5oaSxTVkdGRU1lcmdlRWxlbWVudDpQLmhpLFNWR0ZFTWVyZ2VOb2RlRWxlbWVudDpQLmhpLFNW
+R0ZFTW9ycGhvbG9neUVsZW1lbnQ6UC5oaSxTVkdGRU9mZnNldEVsZW1lbnQ6UC5oaSxTVkdGRVBvaW50
+TGlnaHRFbGVtZW50OlAuaGksU1ZHRkVTcGVjdWxhckxpZ2h0aW5nRWxlbWVudDpQLmhpLFNWR0ZFU3Bv
+dExpZ2h0RWxlbWVudDpQLmhpLFNWR0ZFVGlsZUVsZW1lbnQ6UC5oaSxTVkdGRVR1cmJ1bGVuY2VFbGVt
+ZW50OlAuaGksU1ZHRmlsdGVyRWxlbWVudDpQLmhpLFNWR0ZvcmVpZ25PYmplY3RFbGVtZW50OlAuaGks
+U1ZHR0VsZW1lbnQ6UC5oaSxTVkdHZW9tZXRyeUVsZW1lbnQ6UC5oaSxTVkdHcmFwaGljc0VsZW1lbnQ6
+UC5oaSxTVkdJbWFnZUVsZW1lbnQ6UC5oaSxTVkdMaW5lRWxlbWVudDpQLmhpLFNWR0xpbmVhckdyYWRp
+ZW50RWxlbWVudDpQLmhpLFNWR01hcmtlckVsZW1lbnQ6UC5oaSxTVkdNYXNrRWxlbWVudDpQLmhpLFNW
+R01ldGFkYXRhRWxlbWVudDpQLmhpLFNWR1BhdGhFbGVtZW50OlAuaGksU1ZHUGF0dGVybkVsZW1lbnQ6
+UC5oaSxTVkdQb2x5Z29uRWxlbWVudDpQLmhpLFNWR1BvbHlsaW5lRWxlbWVudDpQLmhpLFNWR1JhZGlh
+bEdyYWRpZW50RWxlbWVudDpQLmhpLFNWR1JlY3RFbGVtZW50OlAuaGksU1ZHU2V0RWxlbWVudDpQLmhp
+LFNWR1N0b3BFbGVtZW50OlAuaGksU1ZHU3R5bGVFbGVtZW50OlAuaGksU1ZHU1ZHRWxlbWVudDpQLmhp
+LFNWR1N3aXRjaEVsZW1lbnQ6UC5oaSxTVkdTeW1ib2xFbGVtZW50OlAuaGksU1ZHVFNwYW5FbGVtZW50
+OlAuaGksU1ZHVGV4dENvbnRlbnRFbGVtZW50OlAuaGksU1ZHVGV4dEVsZW1lbnQ6UC5oaSxTVkdUZXh0
+UGF0aEVsZW1lbnQ6UC5oaSxTVkdUZXh0UG9zaXRpb25pbmdFbGVtZW50OlAuaGksU1ZHVGl0bGVFbGVt
+ZW50OlAuaGksU1ZHVXNlRWxlbWVudDpQLmhpLFNWR1ZpZXdFbGVtZW50OlAuaGksU1ZHR3JhZGllbnRF
+bGVtZW50OlAuaGksU1ZHQ29tcG9uZW50VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQ6UC5oaSxTVkdGRURy
+b3BTaGFkb3dFbGVtZW50OlAuaGksU1ZHTVBhdGhFbGVtZW50OlAuaGksU1ZHRWxlbWVudDpQLmhpfSkK
+aHVua0hlbHBlcnMuc2V0T3JVcGRhdGVMZWFmVGFncyh7RE9NRXJyb3I6dHJ1ZSxNZWRpYUVycm9yOnRy
+dWUsTmF2aWdhdG9yOnRydWUsTmF2aWdhdG9yQ29uY3VycmVudEhhcmR3YXJlOnRydWUsTmF2aWdhdG9y
+VXNlck1lZGlhRXJyb3I6dHJ1ZSxPdmVyY29uc3RyYWluZWRFcnJvcjp0cnVlLFBvc2l0aW9uRXJyb3I6
+dHJ1ZSxSYW5nZTp0cnVlLFNRTEVycm9yOnRydWUsRGF0YVZpZXc6dHJ1ZSxBcnJheUJ1ZmZlclZpZXc6
+ZmFsc2UsRmxvYXQzMkFycmF5OnRydWUsRmxvYXQ2NEFycmF5OnRydWUsSW50MTZBcnJheTp0cnVlLElu
+dDMyQXJyYXk6dHJ1ZSxJbnQ4QXJyYXk6dHJ1ZSxVaW50MTZBcnJheTp0cnVlLFVpbnQzMkFycmF5OnRy
+dWUsVWludDhDbGFtcGVkQXJyYXk6dHJ1ZSxDYW52YXNQaXhlbEFycmF5OnRydWUsVWludDhBcnJheTpm
+YWxzZSxIVE1MQXVkaW9FbGVtZW50OnRydWUsSFRNTEJSRWxlbWVudDp0cnVlLEhUTUxCdXR0b25FbGVt
+ZW50OnRydWUsSFRNTENhbnZhc0VsZW1lbnQ6dHJ1ZSxIVE1MQ29udGVudEVsZW1lbnQ6dHJ1ZSxIVE1M
+RExpc3RFbGVtZW50OnRydWUsSFRNTERhdGFFbGVtZW50OnRydWUsSFRNTERhdGFMaXN0RWxlbWVudDp0
+cnVlLEhUTUxEZXRhaWxzRWxlbWVudDp0cnVlLEhUTUxEaWFsb2dFbGVtZW50OnRydWUsSFRNTERpdkVs
+ZW1lbnQ6dHJ1ZSxIVE1MRW1iZWRFbGVtZW50OnRydWUsSFRNTEZpZWxkU2V0RWxlbWVudDp0cnVlLEhU
+TUxIUkVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZEVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZGluZ0VsZW1lbnQ6dHJ1
+ZSxIVE1MSHRtbEVsZW1lbnQ6dHJ1ZSxIVE1MSUZyYW1lRWxlbWVudDp0cnVlLEhUTUxJbWFnZUVsZW1l
+bnQ6dHJ1ZSxIVE1MSW5wdXRFbGVtZW50OnRydWUsSFRNTExJRWxlbWVudDp0cnVlLEhUTUxMYWJlbEVs
+ZW1lbnQ6dHJ1ZSxIVE1MTGVnZW5kRWxlbWVudDp0cnVlLEhUTUxMaW5rRWxlbWVudDp0cnVlLEhUTUxN
+YXBFbGVtZW50OnRydWUsSFRNTE1lZGlhRWxlbWVudDp0cnVlLEhUTUxNZW51RWxlbWVudDp0cnVlLEhU
+TUxNZXRhRWxlbWVudDp0cnVlLEhUTUxNZXRlckVsZW1lbnQ6dHJ1ZSxIVE1MTW9kRWxlbWVudDp0cnVl
+LEhUTUxPTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MT2JqZWN0RWxlbWVudDp0cnVlLEhUTUxPcHRHcm91cEVs
+ZW1lbnQ6dHJ1ZSxIVE1MT3B0aW9uRWxlbWVudDp0cnVlLEhUTUxPdXRwdXRFbGVtZW50OnRydWUsSFRN
+TFBhcmFtRWxlbWVudDp0cnVlLEhUTUxQaWN0dXJlRWxlbWVudDp0cnVlLEhUTUxQcmVFbGVtZW50OnRy
+dWUsSFRNTFByb2dyZXNzRWxlbWVudDp0cnVlLEhUTUxRdW90ZUVsZW1lbnQ6dHJ1ZSxIVE1MU2NyaXB0
+RWxlbWVudDp0cnVlLEhUTUxTaGFkb3dFbGVtZW50OnRydWUsSFRNTFNsb3RFbGVtZW50OnRydWUsSFRN
+TFNvdXJjZUVsZW1lbnQ6dHJ1ZSxIVE1MU3BhbkVsZW1lbnQ6dHJ1ZSxIVE1MU3R5bGVFbGVtZW50OnRy
+dWUsSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVDZWxsRWxlbWVudDp0cnVlLEhU
+TUxUYWJsZURhdGFDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZUhlYWRlckNlbGxFbGVtZW50OnRydWUs
+SFRNTFRhYmxlQ29sRWxlbWVudDp0cnVlLEhUTUxUZXh0QXJlYUVsZW1lbnQ6dHJ1ZSxIVE1MVGltZUVs
+ZW1lbnQ6dHJ1ZSxIVE1MVGl0bGVFbGVtZW50OnRydWUsSFRNTFRyYWNrRWxlbWVudDp0cnVlLEhUTUxV
+TGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MVW5rbm93bkVsZW1lbnQ6dHJ1ZSxIVE1MVmlkZW9FbGVtZW50OnRy
+dWUsSFRNTERpcmVjdG9yeUVsZW1lbnQ6dHJ1ZSxIVE1MRm9udEVsZW1lbnQ6dHJ1ZSxIVE1MRnJhbWVF
+bGVtZW50OnRydWUsSFRNTEZyYW1lU2V0RWxlbWVudDp0cnVlLEhUTUxNYXJxdWVlRWxlbWVudDp0cnVl
+LEhUTUxFbGVtZW50OmZhbHNlLEhUTUxBbmNob3JFbGVtZW50OnRydWUsSFRNTEFyZWFFbGVtZW50OnRy
+dWUsSFRNTEJhc2VFbGVtZW50OnRydWUsQmxvYjpmYWxzZSxIVE1MQm9keUVsZW1lbnQ6dHJ1ZSxDREFU
+QVNlY3Rpb246dHJ1ZSxDaGFyYWN0ZXJEYXRhOnRydWUsQ29tbWVudDp0cnVlLFByb2Nlc3NpbmdJbnN0
+cnVjdGlvbjp0cnVlLFRleHQ6dHJ1ZSxDU1NTdHlsZURlY2xhcmF0aW9uOnRydWUsTVNTdHlsZUNTU1By
+b3BlcnRpZXM6dHJ1ZSxDU1MyUHJvcGVydGllczp0cnVlLFhNTERvY3VtZW50OnRydWUsRG9jdW1lbnQ6
+ZmFsc2UsRE9NRXhjZXB0aW9uOnRydWUsRE9NSW1wbGVtZW50YXRpb246dHJ1ZSxET01SZWN0UmVhZE9u
+bHk6ZmFsc2UsRE9NVG9rZW5MaXN0OnRydWUsRWxlbWVudDpmYWxzZSxBYm9ydFBheW1lbnRFdmVudDp0
+cnVlLEFuaW1hdGlvbkV2ZW50OnRydWUsQW5pbWF0aW9uUGxheWJhY2tFdmVudDp0cnVlLEFwcGxpY2F0
+aW9uQ2FjaGVFcnJvckV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVudDp0cnVlLEJhY2tn
+cm91bmRGZXRjaEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50OnRydWUsQmFja2dyb3Vu
+ZEZldGNoZWRFdmVudDp0cnVlLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDp0cnVlLEJlZm9yZVVubG9h
+ZEV2ZW50OnRydWUsQmxvYkV2ZW50OnRydWUsQ2FuTWFrZVBheW1lbnRFdmVudDp0cnVlLENsaXBib2Fy
+ZEV2ZW50OnRydWUsQ2xvc2VFdmVudDp0cnVlLEN1c3RvbUV2ZW50OnRydWUsRGV2aWNlTW90aW9uRXZl
+bnQ6dHJ1ZSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OnRydWUsRXJyb3JFdmVudDp0cnVlLEV4dGVuZGFi
+bGVFdmVudDp0cnVlLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6dHJ1ZSxGZXRjaEV2ZW50OnRydWUsRm9u
+dEZhY2VTZXRMb2FkRXZlbnQ6dHJ1ZSxGb3JlaWduRmV0Y2hFdmVudDp0cnVlLEdhbWVwYWRFdmVudDp0
+cnVlLEhhc2hDaGFuZ2VFdmVudDp0cnVlLEluc3RhbGxFdmVudDp0cnVlLE1lZGlhRW5jcnlwdGVkRXZl
+bnQ6dHJ1ZSxNZWRpYUtleU1lc3NhZ2VFdmVudDp0cnVlLE1lZGlhUXVlcnlMaXN0RXZlbnQ6dHJ1ZSxN
+ZWRpYVN0cmVhbUV2ZW50OnRydWUsTWVkaWFTdHJlYW1UcmFja0V2ZW50OnRydWUsTWVzc2FnZUV2ZW50
+OnRydWUsTUlESUNvbm5lY3Rpb25FdmVudDp0cnVlLE1JRElNZXNzYWdlRXZlbnQ6dHJ1ZSxNdXRhdGlv
+bkV2ZW50OnRydWUsTm90aWZpY2F0aW9uRXZlbnQ6dHJ1ZSxQYWdlVHJhbnNpdGlvbkV2ZW50OnRydWUs
+UGF5bWVudFJlcXVlc3RFdmVudDp0cnVlLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZlbnQ6dHJ1ZSxQb3BT
+dGF0ZUV2ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2ZW50OnRydWUsUHJl
+c2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6dHJ1ZSxQcm9taXNlUmVqZWN0aW9uRXZlbnQ6dHJ1
+ZSxQdXNoRXZlbnQ6dHJ1ZSxSVENEYXRhQ2hhbm5lbEV2ZW50OnRydWUsUlRDRFRNRlRvbmVDaGFuZ2VF
+dmVudDp0cnVlLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6dHJ1ZSxSVENUcmFja0V2ZW50OnRydWUs
+U2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDp0cnVlLFNlbnNvckVycm9yRXZlbnQ6dHJ1ZSxTcGVl
+Y2hSZWNvZ25pdGlvbkVycm9yOnRydWUsU3BlZWNoUmVjb2duaXRpb25FdmVudDp0cnVlLFNwZWVjaFN5
+bnRoZXNpc0V2ZW50OnRydWUsU3RvcmFnZUV2ZW50OnRydWUsU3luY0V2ZW50OnRydWUsVHJhY2tFdmVu
+dDp0cnVlLFRyYW5zaXRpb25FdmVudDp0cnVlLFdlYktpdFRyYW5zaXRpb25FdmVudDp0cnVlLFZSRGV2
+aWNlRXZlbnQ6dHJ1ZSxWUkRpc3BsYXlFdmVudDp0cnVlLFZSU2Vzc2lvbkV2ZW50OnRydWUsTW9qb0lu
+dGVyZmFjZVJlcXVlc3RFdmVudDp0cnVlLFVTQkNvbm5lY3Rpb25FdmVudDp0cnVlLElEQlZlcnNpb25D
+aGFuZ2VFdmVudDp0cnVlLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OnRydWUsT2ZmbGluZUF1ZGlvQ29tcGxl
+dGlvbkV2ZW50OnRydWUsV2ViR0xDb250ZXh0RXZlbnQ6dHJ1ZSxFdmVudDpmYWxzZSxJbnB1dEV2ZW50
+OmZhbHNlLFN1Ym1pdEV2ZW50OmZhbHNlLEV2ZW50VGFyZ2V0OmZhbHNlLEZpbGU6dHJ1ZSxIVE1MRm9y
+bUVsZW1lbnQ6dHJ1ZSxIaXN0b3J5OnRydWUsSFRNTERvY3VtZW50OnRydWUsWE1MSHR0cFJlcXVlc3Q6
+dHJ1ZSxYTUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0OmZhbHNlLEltYWdlRGF0YTp0cnVlLExvY2F0aW9u
+OnRydWUsTW91c2VFdmVudDp0cnVlLERyYWdFdmVudDp0cnVlLFBvaW50ZXJFdmVudDp0cnVlLFdoZWVs
+RXZlbnQ6dHJ1ZSxEb2N1bWVudEZyYWdtZW50OnRydWUsU2hhZG93Um9vdDp0cnVlLERvY3VtZW50VHlw
+ZTp0cnVlLE5vZGU6ZmFsc2UsTm9kZUxpc3Q6dHJ1ZSxSYWRpb05vZGVMaXN0OnRydWUsSFRNTFBhcmFn
+cmFwaEVsZW1lbnQ6dHJ1ZSxQcm9ncmVzc0V2ZW50OnRydWUsUmVzb3VyY2VQcm9ncmVzc0V2ZW50OnRy
+dWUsSFRNTFNlbGVjdEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVFbGVtZW50OnRydWUsSFRNTFRhYmxlUm93
+RWxlbWVudDp0cnVlLEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OnRydWUsSFRNTFRlbXBsYXRlRWxlbWVu
+dDp0cnVlLENvbXBvc2l0aW9uRXZlbnQ6dHJ1ZSxGb2N1c0V2ZW50OnRydWUsS2V5Ym9hcmRFdmVudDp0
+cnVlLFRleHRFdmVudDp0cnVlLFRvdWNoRXZlbnQ6dHJ1ZSxVSUV2ZW50OmZhbHNlLFdpbmRvdzp0cnVl
+LERPTVdpbmRvdzp0cnVlLERlZGljYXRlZFdvcmtlckdsb2JhbFNjb3BlOnRydWUsU2VydmljZVdvcmtl
+ckdsb2JhbFNjb3BlOnRydWUsU2hhcmVkV29ya2VyR2xvYmFsU2NvcGU6dHJ1ZSxXb3JrZXJHbG9iYWxT
+Y29wZTp0cnVlLEF0dHI6dHJ1ZSxDbGllbnRSZWN0OnRydWUsRE9NUmVjdDp0cnVlLE5hbWVkTm9kZU1h
+cDp0cnVlLE1vek5hbWVkQXR0ck1hcDp0cnVlLElEQktleVJhbmdlOnRydWUsU1ZHU2NyaXB0RWxlbWVu
+dDp0cnVlLFNWR0FFbGVtZW50OnRydWUsU1ZHQW5pbWF0ZUVsZW1lbnQ6dHJ1ZSxTVkdBbmltYXRlTW90
+aW9uRWxlbWVudDp0cnVlLFNWR0FuaW1hdGVUcmFuc2Zvcm1FbGVtZW50OnRydWUsU1ZHQW5pbWF0aW9u
+RWxlbWVudDp0cnVlLFNWR0NpcmNsZUVsZW1lbnQ6dHJ1ZSxTVkdDbGlwUGF0aEVsZW1lbnQ6dHJ1ZSxT
+VkdEZWZzRWxlbWVudDp0cnVlLFNWR0Rlc2NFbGVtZW50OnRydWUsU1ZHRGlzY2FyZEVsZW1lbnQ6dHJ1
+ZSxTVkdFbGxpcHNlRWxlbWVudDp0cnVlLFNWR0ZFQmxlbmRFbGVtZW50OnRydWUsU1ZHRkVDb2xvck1h
+dHJpeEVsZW1lbnQ6dHJ1ZSxTVkdGRUNvbXBvbmVudFRyYW5zZmVyRWxlbWVudDp0cnVlLFNWR0ZFQ29t
+cG9zaXRlRWxlbWVudDp0cnVlLFNWR0ZFQ29udm9sdmVNYXRyaXhFbGVtZW50OnRydWUsU1ZHRkVEaWZm
+dXNlTGlnaHRpbmdFbGVtZW50OnRydWUsU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50OnRydWUsU1ZH
+RkVEaXN0YW50TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVGbG9vZEVsZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNB
+RWxlbWVudDp0cnVlLFNWR0ZFRnVuY0JFbGVtZW50OnRydWUsU1ZHRkVGdW5jR0VsZW1lbnQ6dHJ1ZSxT
+VkdGRUZ1bmNSRWxlbWVudDp0cnVlLFNWR0ZFR2F1c3NpYW5CbHVyRWxlbWVudDp0cnVlLFNWR0ZFSW1h
+Z2VFbGVtZW50OnRydWUsU1ZHRkVNZXJnZUVsZW1lbnQ6dHJ1ZSxTVkdGRU1lcmdlTm9kZUVsZW1lbnQ6
+dHJ1ZSxTVkdGRU1vcnBob2xvZ3lFbGVtZW50OnRydWUsU1ZHRkVPZmZzZXRFbGVtZW50OnRydWUsU1ZH
+RkVQb2ludExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFU3BlY3VsYXJMaWdodGluZ0VsZW1lbnQ6dHJ1ZSxT
+VkdGRVNwb3RMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVRpbGVFbGVtZW50OnRydWUsU1ZHRkVUdXJidWxl
+bmNlRWxlbWVudDp0cnVlLFNWR0ZpbHRlckVsZW1lbnQ6dHJ1ZSxTVkdGb3JlaWduT2JqZWN0RWxlbWVu
+dDp0cnVlLFNWR0dFbGVtZW50OnRydWUsU1ZHR2VvbWV0cnlFbGVtZW50OnRydWUsU1ZHR3JhcGhpY3NF
+bGVtZW50OnRydWUsU1ZHSW1hZ2VFbGVtZW50OnRydWUsU1ZHTGluZUVsZW1lbnQ6dHJ1ZSxTVkdMaW5l
+YXJHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdNYXJrZXJFbGVtZW50OnRydWUsU1ZHTWFza0VsZW1lbnQ6
+dHJ1ZSxTVkdNZXRhZGF0YUVsZW1lbnQ6dHJ1ZSxTVkdQYXRoRWxlbWVudDp0cnVlLFNWR1BhdHRlcm5F
+bGVtZW50OnRydWUsU1ZHUG9seWdvbkVsZW1lbnQ6dHJ1ZSxTVkdQb2x5bGluZUVsZW1lbnQ6dHJ1ZSxT
+VkdSYWRpYWxHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdSZWN0RWxlbWVudDp0cnVlLFNWR1NldEVsZW1l
+bnQ6dHJ1ZSxTVkdTdG9wRWxlbWVudDp0cnVlLFNWR1N0eWxlRWxlbWVudDp0cnVlLFNWR1NWR0VsZW1l
+bnQ6dHJ1ZSxTVkdTd2l0Y2hFbGVtZW50OnRydWUsU1ZHU3ltYm9sRWxlbWVudDp0cnVlLFNWR1RTcGFu
+RWxlbWVudDp0cnVlLFNWR1RleHRDb250ZW50RWxlbWVudDp0cnVlLFNWR1RleHRFbGVtZW50OnRydWUs
+U1ZHVGV4dFBhdGhFbGVtZW50OnRydWUsU1ZHVGV4dFBvc2l0aW9uaW5nRWxlbWVudDp0cnVlLFNWR1Rp
+dGxlRWxlbWVudDp0cnVlLFNWR1VzZUVsZW1lbnQ6dHJ1ZSxTVkdWaWV3RWxlbWVudDp0cnVlLFNWR0dy
+YWRpZW50RWxlbWVudDp0cnVlLFNWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVtZW50OnRydWUs
+U1ZHRkVEcm9wU2hhZG93RWxlbWVudDp0cnVlLFNWR01QYXRoRWxlbWVudDp0cnVlLFNWR0VsZW1lbnQ6
+ZmFsc2V9KQpILkxaLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguUkcuJG5h
+dGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5WUC4kbmF0aXZlU3VwZXJjbGFzc1Rh
+Zz0iQXJyYXlCdWZmZXJWaWV3IgpILkRnLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZp
+ZXciCkguV0IuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5aRy4kbmF0aXZl
+U3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILlBnLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJB
+cnJheUJ1ZmZlclZpZXcifSkoKQpjb252ZXJ0QWxsVG9GYXN0T2JqZWN0KHcpCmNvbnZlcnRUb0Zhc3RP
+YmplY3QoJCk7KGZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBkb2N1bWVudD09PSJ1bmRlZmluZWQiKXthKG51
+bGwpCnJldHVybn1pZih0eXBlb2YgZG9jdW1lbnQuY3VycmVudFNjcmlwdCE9InVuZGVmaW5lZCIpe2Eo
+ZG9jdW1lbnQuY3VycmVudFNjcmlwdCkKcmV0dXJufXZhciBzPWRvY3VtZW50LnNjcmlwdHMKZnVuY3Rp
+b24gb25Mb2FkKGIpe2Zvcih2YXIgcT0wO3E8cy5sZW5ndGg7KytxKXNbcV0ucmVtb3ZlRXZlbnRMaXN0
+ZW5lcigibG9hZCIsb25Mb2FkLGZhbHNlKQphKGIudGFyZ2V0KX1mb3IodmFyIHI9MDtyPHMubGVuZ3Ro
+OysrcilzW3JdLmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLG9uTG9hZCxmYWxzZSl9KShmdW5jdGlvbihh
+KXt2LmN1cnJlbnRTY3JpcHQ9YQp2YXIgcz1MLklxCmlmKHR5cGVvZiBkYXJ0TWFpblJ1bm5lcj09PSJm
+dW5jdGlvbiIpZGFydE1haW5SdW5uZXIocyxbXSkKZWxzZSBzKFtdKX0pfSkoKQovLyMgc291cmNlTWFw
+cGluZ1VSTD1taWdyYXRpb24uanMubWFwCg==
''';
diff --git a/pkg/nnbd_migration/lib/src/front_end/web/edit_details.dart b/pkg/nnbd_migration/lib/src/front_end/web/edit_details.dart
index b416b03..f5ad437 100644
--- a/pkg/nnbd_migration/lib/src/front_end/web/edit_details.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/web/edit_details.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:meta/meta.dart';
-import 'package:nnbd_migration/src/front_end/migration_info.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
/// Information about what should be populated into the "Edit Details" view of
/// the migration preview tool.
diff --git a/pkg/nnbd_migration/lib/src/front_end/web/migration.dart b/pkg/nnbd_migration/lib/src/front_end/web/migration.dart
index e465aec..0c2ddb8 100644
--- a/pkg/nnbd_migration/lib/src/front_end/web/migration.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/web/migration.dart
@@ -6,11 +6,10 @@
import 'dart:convert';
import 'dart:html';
-import 'package:nnbd_migration/instrumentation.dart';
-import 'package:nnbd_migration/src/front_end/migration_info.dart';
import 'package:nnbd_migration/src/front_end/web/edit_details.dart';
import 'package:nnbd_migration/src/front_end/web/file_details.dart';
import 'package:nnbd_migration/src/front_end/web/navigation_tree.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:path/path.dart' as _p;
import 'highlight_js.dart';
diff --git a/pkg/nnbd_migration/lib/src/hint_action.dart b/pkg/nnbd_migration/lib/src/hint_action.dart
new file mode 100644
index 0000000..3d2103f
--- /dev/null
+++ b/pkg/nnbd_migration/lib/src/hint_action.dart
@@ -0,0 +1,71 @@
+// 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.
+
+/// Everything the front end needs to know to tell the server to perform a hint
+/// action.
+class HintAction {
+ final HintActionKind kind;
+ final int nodeId;
+ HintAction(this.kind, this.nodeId);
+
+ HintAction.fromJson(Map<String, Object> json)
+ : nodeId = json['nodeId'] as int,
+ kind = HintActionKind.values
+ .singleWhere((action) => action.index == json['kind']);
+
+ Map<String, Object> toJson() => {
+ 'nodeId': nodeId,
+ 'kind': kind.index,
+ };
+}
+
+/// Enum describing the possible hints that can be performed on an edge or a
+/// node.
+///
+/// Which actions are available can be built by other visitors, and the hint can
+/// be applied by visitors such as EditPlanner when the user requests it from
+/// the front end.
+enum HintActionKind {
+ /// Add a `/*?*/` hint to a type.
+ addNullableHint,
+
+ /// Add a `/*!*/` hint to a type.
+ addNonNullableHint,
+
+ /// Change a `/*!*/` hint to a `/*?*/` hint.
+ changeToNullableHint,
+
+ /// Change a `/*?*/` hint to a `/*!*/` hint.
+ changeToNonNullableHint,
+
+ /// Remove a `/*?*/` hint.
+ removeNullableHint,
+
+ /// Remove a `/*!*/` hint.
+ removeNonNullableHint,
+}
+
+/// Extension methods to make [HintActionKind] act as a smart enum.
+extension HintActionKindBehaviors on HintActionKind {
+ /// Get the text description of a [HintActionKind], for display to users.
+ String get description {
+ switch (this) {
+ case HintActionKind.addNullableHint:
+ return 'Add /*?*/ hint';
+ case HintActionKind.addNonNullableHint:
+ return 'Add /*!*/ hint';
+ case HintActionKind.removeNullableHint:
+ return 'Remove /*?*/ hint';
+ case HintActionKind.removeNonNullableHint:
+ return 'Remove /*!*/ hint';
+ case HintActionKind.changeToNullableHint:
+ return 'Change to /*?*/ hint';
+ case HintActionKind.changeToNonNullableHint:
+ return 'Change to /*!*/ hint';
+ }
+
+ assert(false);
+ return null;
+ }
+}
diff --git a/pkg/nnbd_migration/lib/src/node_builder.dart b/pkg/nnbd_migration/lib/src/node_builder.dart
index 77c9de8..3c5e862 100644
--- a/pkg/nnbd_migration/lib/src/node_builder.dart
+++ b/pkg/nnbd_migration/lib/src/node_builder.dart
@@ -15,6 +15,7 @@
import 'package:nnbd_migration/nnbd_migration.dart';
import 'package:nnbd_migration/src/decorated_type.dart';
import 'package:nnbd_migration/src/edit_plan.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/nullability_node.dart';
import 'package:nnbd_migration/src/nullability_node_target.dart';
import 'package:nnbd_migration/src/utilities/completeness_tracker.dart';
diff --git a/pkg/nnbd_migration/lib/src/nullability_node.dart b/pkg/nnbd_migration/lib/src/nullability_node.dart
index 7b4b56f..85fa200 100644
--- a/pkg/nnbd_migration/lib/src/nullability_node.dart
+++ b/pkg/nnbd_migration/lib/src/nullability_node.dart
@@ -11,6 +11,7 @@
import 'package:nnbd_migration/nullability_state.dart';
import 'package:nnbd_migration/src/edit_plan.dart';
import 'package:nnbd_migration/src/expression_checks.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/nullability_node_target.dart';
import 'package:nnbd_migration/src/postmortem_file.dart';
diff --git a/pkg/nnbd_migration/lib/src/preview/preview_site.dart b/pkg/nnbd_migration/lib/src/preview/preview_site.dart
index 9799335..c02b3c1 100644
--- a/pkg/nnbd_migration/lib/src/preview/preview_site.dart
+++ b/pkg/nnbd_migration/lib/src/preview/preview_site.dart
@@ -16,6 +16,7 @@
import 'package:nnbd_migration/src/front_end/migration_state.dart';
import 'package:nnbd_migration/src/front_end/path_mapper.dart';
import 'package:nnbd_migration/src/front_end/web/navigation_tree.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/preview/dart_file_page.dart';
import 'package:nnbd_migration/src/preview/dart_logo_page.dart';
import 'package:nnbd_migration/src/preview/exception_page.dart';
diff --git a/pkg/nnbd_migration/test/front_end/info_builder_test.dart b/pkg/nnbd_migration/test/front_end/info_builder_test.dart
index b4f76ed..45292fd 100644
--- a/pkg/nnbd_migration/test/front_end/info_builder_test.dart
+++ b/pkg/nnbd_migration/test/front_end/info_builder_test.dart
@@ -5,10 +5,10 @@
import 'package:analyzer/dart/analysis/results.dart';
import 'package:analyzer/dart/ast/ast.dart';
import 'package:meta/meta.dart';
-import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/nnbd_migration.dart';
import 'package:nnbd_migration/src/front_end/info_builder.dart';
import 'package:nnbd_migration/src/front_end/migration_info.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/nnbd_migration/test/front_end/nnbd_migration_test_base.dart b/pkg/nnbd_migration/test/front_end/nnbd_migration_test_base.dart
index 9ffa68c..2622ed5 100644
--- a/pkg/nnbd_migration/test/front_end/nnbd_migration_test_base.dart
+++ b/pkg/nnbd_migration/test/front_end/nnbd_migration_test_base.dart
@@ -14,6 +14,7 @@
import 'package:nnbd_migration/src/front_end/migration_info.dart';
import 'package:nnbd_migration/src/front_end/non_nullable_fix.dart';
import 'package:nnbd_migration/src/front_end/offset_mapper.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -158,6 +159,8 @@
var includedRoot = resourceProvider.pathContext.dirname(testFile);
await _buildMigrationInfo([testFile],
includedRoot: includedRoot,
+ shouldBeMigratedFunction: (String path) => true,
+ pathsToProcess: [testFile],
removeViaComments: removeViaComments,
warnOnWeakCode: warnOnWeakCode);
}
@@ -189,13 +192,20 @@
///
/// Returns the singular [UnitInfo] which was built.
Future<List<UnitInfo>> buildInfoForTestFiles(Map<String, String> files,
- {String includedRoot}) async {
+ {@required String includedRoot,
+ bool Function(String) shouldBeMigratedFunction,
+ Iterable<String> pathsToProcess}) async {
+ shouldBeMigratedFunction ??= (String path) => true;
var testPaths = <String>[];
files.forEach((String path, String content) {
newFile(path, content: content);
testPaths.add(path);
});
- await _buildMigrationInfo(testPaths, includedRoot: includedRoot);
+ pathsToProcess ??= testPaths;
+ await _buildMigrationInfo(testPaths,
+ includedRoot: includedRoot,
+ shouldBeMigratedFunction: shouldBeMigratedFunction,
+ pathsToProcess: pathsToProcess);
// Ignore info for dart:core.
var filteredInfos = [
for (var info in infos)
@@ -211,8 +221,10 @@
/// Uses the InfoBuilder to build information for files at [testPaths], which
/// should all share a common parent directory, [includedRoot].
- Future<void> _buildMigrationInfo(List<String> testPaths,
- {String includedRoot,
+ Future<void> _buildMigrationInfo(Iterable<String> testPaths,
+ {@required String includedRoot,
+ @required bool Function(String) shouldBeMigratedFunction,
+ @required Iterable<String> pathsToProcess,
bool removeViaComments = true,
bool warnOnWeakCode = false}) async {
// Compute the analysis results.
@@ -242,8 +254,16 @@
// Build the migration info.
var info = instrumentationListener.data;
var logger = TestLogger(false);
- var builder = InfoBuilder(resourceProvider, includedRoot, info, listener,
- migration, nodeMapper, logger, (String path) => true);
+ var builder = InfoBuilder(
+ resourceProvider,
+ includedRoot,
+ info,
+ listener,
+ migration,
+ nodeMapper,
+ logger,
+ shouldBeMigratedFunction,
+ pathsToProcess);
infos = await builder.explainMigration();
}
}
diff --git a/pkg/nnbd_migration/test/node_builder_test.dart b/pkg/nnbd_migration/test/node_builder_test.dart
index 870e29a..54d4aa1 100644
--- a/pkg/nnbd_migration/test/node_builder_test.dart
+++ b/pkg/nnbd_migration/test/node_builder_test.dart
@@ -3,9 +3,9 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/dart/element/type.dart';
-import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/src/decorated_type.dart';
import 'package:nnbd_migration/src/edit_plan.dart';
+import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/nullability_node.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
diff --git a/pkg/nnbd_migration/test/preview/preview_site_test.dart b/pkg/nnbd_migration/test/preview/preview_site_test.dart
index ca9348c..d351962 100644
--- a/pkg/nnbd_migration/test/preview/preview_site_test.dart
+++ b/pkg/nnbd_migration/test/preview/preview_site_test.dart
@@ -269,13 +269,20 @@
with ResourceProviderMixin, PreviewSiteTestMixin {
MigrationInfo migrationInfo;
- Future<void> setUpMigrationInfo(Map<String, String> files) async {
- await buildInfoForTestFiles(files, includedRoot: projectPath);
+ Future<void> setUpMigrationInfo(Map<String, String> files,
+ {bool Function(String) shouldBeMigratedFunction,
+ Iterable<String> pathsToProcess}) async {
+ shouldBeMigratedFunction ??= (String path) => true;
+ pathsToProcess ??= files.keys;
+ await buildInfoForTestFiles(files,
+ includedRoot: projectPath,
+ shouldBeMigratedFunction: shouldBeMigratedFunction,
+ pathsToProcess: pathsToProcess);
dartfixListener = DartFixListener(null, ListenerClient());
migrationInfo =
MigrationInfo(infos, {}, resourceProvider.pathContext, projectPath);
state = MigrationState(
- null, null, dartfixListener, null, {}, (String path) => true);
+ null, null, dartfixListener, null, {}, shouldBeMigratedFunction);
nodeMapper = state.nodeMapper;
state.pathMapper = PathMapper(resourceProvider);
state.migrationInfo = migrationInfo;
@@ -469,6 +476,32 @@
'''));
}
+ void test_applyMigration_doNotOptOutFileNotInPathsToProcess() async {
+ final pathA = convertPath('$projectPath/lib/a.dart');
+ final pathB = convertPath('$projectPath/lib/b.dart');
+ final content = 'void main() {}';
+ await setUpMigrationInfo({pathA: content, pathB: content},
+ // Neither [pathA] nor [[pathB] should be migrated.
+ shouldBeMigratedFunction: (String path) => false,
+ pathsToProcess: [pathA]);
+ site.unitInfoMap[pathA] = UnitInfo(pathA)
+ ..diskContent = content
+ ..wasExplicitlyOptedOut = false
+ ..migrationStatus = UnitMigrationStatus.optingOut;
+ site.unitInfoMap[pathB] = UnitInfo(pathB)
+ ..diskContent = content
+ ..wasExplicitlyOptedOut = false
+ ..migrationStatus = UnitMigrationStatus.optingOut;
+ var navigationTree =
+ NavigationTreeRenderer(migrationInfo, state.pathMapper).render();
+ site.performApply(navigationTree);
+ expect(getFile(pathA).readAsStringSync(), '''
+// @dart=2.9
+
+void main() {}''');
+ expect(getFile(pathB).readAsStringSync(), 'void main() {}');
+ }
+
void test_applyMigration_optOutOne_migrateAnother() async {
final pathA = convertPath('$projectPath/lib/a.dart');
final pathB = convertPath('$projectPath/lib/b.dart');
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index a192694..b8b187c 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -1326,9 +1326,20 @@
_makeUnreachableBody(node.function);
}
node.function.asyncMarker = AsyncMarker.Sync;
- if (node.concreteForwardingStubTarget != null ||
- node.abstractForwardingStubTarget != null) {
- node.stubTarget = null;
+ switch (node.stubKind) {
+ case ProcedureStubKind.Regular:
+ case ProcedureStubKind.NoSuchMethodForwarder:
+ break;
+ case ProcedureStubKind.MemberSignature:
+ case ProcedureStubKind.AbstractForwardingStub:
+ case ProcedureStubKind.ConcreteForwardingStub:
+ case ProcedureStubKind.AbstractMixinStub:
+ case ProcedureStubKind.ConcreteMixinStub:
+ // Make the stub look like a regular procedure so the stub target
+ // isn't expected to be non-null, for instance by the verifier.
+ node.stubKind = ProcedureStubKind.Regular;
+ node.stubTarget = null;
+ break;
}
Statistics.methodBodiesDropped++;
} else if (node is Field) {
diff --git a/pkg/vm/test/modular_kernel_plus_aot_test.dart b/pkg/vm/test/modular_kernel_plus_aot_test.dart
index ed8c0d2..8b950bd 100644
--- a/pkg/vm/test/modular_kernel_plus_aot_test.dart
+++ b/pkg/vm/test/modular_kernel_plus_aot_test.dart
@@ -157,8 +157,8 @@
}
class Mixin {
void set mixinProperty(v) {}
- Foo get mixinProperty{}
- Foo mixinMethod(v) {}
+ Foo get mixinProperty => new Foo();
+ Foo mixinMethod(v) => new Foo();
}
class A1 extends Object with Mixin { }
class A2 extends Object with Mixin { }
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
index 59e2b69..6fce119 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/invalidation_cycle.dart.expect
@@ -22,7 +22,7 @@
: super core::Object::•()
;
[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:1,getterSelectorId:2] abstract method foobar() → self::StreamSubscription*;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3] abstract member-signature operator ==(dynamic other) → core::bool*; -> core::Object::==
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasNonThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3] abstract operator ==(dynamic other) → core::bool*;
}
abstract class _StreamImpl extends self::Stream {
synthetic constructor •() → self::_StreamImpl*
diff --git a/pkg/vm_service/CHANGELOG.md b/pkg/vm_service/CHANGELOG.md
index 31414a2..2013c32 100644
--- a/pkg/vm_service/CHANGELOG.md
+++ b/pkg/vm_service/CHANGELOG.md
@@ -1,8 +1,19 @@
# Changelog
+
+## 6.0.0-nullsafety.3
+- Fixed issue where `Response.type` and classes which override `Response.type` were
+ returning the name of the `package:vm_service` reference object (e.g., InstanceRef) instead of
+ the type specified in the specification (e.g., @Instance).
+
+## 6.0.0-nullsafety.2
+- *breaking* Updated signature of `Field.staticValue` to `dynamic` in order to
+ properly allow for uninitialized sentinel values.
+
## 6.0.0-nullsafety.1
-- Null safety migration, take two. Assume all object fields are nullable.
+- *breaking* Null safety migration, take two. Assume all object fields are nullable.
+
## 6.0.0-nullsafety-dev
-- Migrate to use null safety.
+- *breaking* Migrate to use null safety.
## 5.5.1
- Fix issue where `VmService.onDone` could complete before the provided `DisposeHandler` had finished executing.
diff --git a/pkg/vm_service/lib/src/vm_service.dart b/pkg/vm_service/lib/src/vm_service.dart
index 031eb06..05cbc00 100644
--- a/pkg/vm_service/lib/src/vm_service.dart
+++ b/pkg/vm_service/lib/src/vm_service.dart
@@ -2799,7 +2799,7 @@
}
@override
- String get type => 'ClassRef';
+ String get type => '@Class';
@override
Map<String, dynamic> toJson() {
@@ -3071,7 +3071,7 @@
}
@override
- String get type => 'CodeRef';
+ String get type => '@Code';
@override
Map<String, dynamic> toJson() {
@@ -3155,7 +3155,7 @@
}
@override
- String get type => 'ContextRef';
+ String get type => '@Context';
@override
Map<String, dynamic> toJson() {
@@ -3445,7 +3445,7 @@
}
@override
- String get type => 'ErrorRef';
+ String get type => '@Error';
@override
Map<String, dynamic> toJson() {
@@ -3883,7 +3883,7 @@
}
@override
- String get type => 'FieldRef';
+ String get type => '@Field';
@override
Map<String, dynamic> toJson() {
@@ -3935,9 +3935,12 @@
/// Is this field static?
bool? isStatic;
- /// The value of this field, if the field is static.
+ /// The value of this field, if the field is static. If uninitialized, this
+ /// will take the value of an uninitialized Sentinel.
+ ///
+ /// [staticValue] can be one of [InstanceRef] or [Sentinel].
@optional
- InstanceRef? staticValue;
+ dynamic? staticValue;
/// The location of this field in the source code.
@optional
@@ -3966,9 +3969,8 @@
isConst = json['const'] ?? false;
isFinal = json['final'] ?? false;
isStatic = json['static'] ?? false;
- staticValue =
- createServiceObject(json['staticValue'], const ['InstanceRef'])
- as InstanceRef?;
+ staticValue = createServiceObject(
+ json['staticValue'], const ['InstanceRef', 'Sentinel']) as dynamic?;
location = createServiceObject(json['location'], const ['SourceLocation'])
as SourceLocation?;
}
@@ -4189,7 +4191,7 @@
}
@override
- String get type => 'FuncRef';
+ String get type => '@Function';
@override
Map<String, dynamic> toJson() {
@@ -4264,7 +4266,7 @@
}
@override
- String get type => 'Func';
+ String get type => 'Function';
@override
Map<String, dynamic> toJson() {
@@ -4461,7 +4463,7 @@
}
@override
- String get type => 'InstanceRef';
+ String get type => '@Instance';
@override
Map<String, dynamic> toJson() {
@@ -4910,7 +4912,7 @@
}
@override
- String get type => 'IsolateRef';
+ String get type => '@Isolate';
@override
Map<String, dynamic> toJson() {
@@ -5152,7 +5154,7 @@
}
@override
- String get type => 'IsolateGroupRef';
+ String get type => '@IsolateGroup';
@override
Map<String, dynamic> toJson() {
@@ -5386,7 +5388,7 @@
}
@override
- String get type => 'LibraryRef';
+ String get type => '@Library';
@override
Map<String, dynamic> toJson() {
@@ -5841,7 +5843,7 @@
}
@override
- String get type => 'NullValRef';
+ String get type => '@Null';
@override
Map<String, dynamic> toJson() {
@@ -5886,7 +5888,7 @@
}
@override
- String get type => 'NullVal';
+ String get type => 'Null';
@override
Map<String, dynamic> toJson() {
@@ -5932,7 +5934,7 @@
}
@override
- String get type => 'ObjRef';
+ String get type => '@Object';
@override
Map<String, dynamic> toJson() {
@@ -6006,7 +6008,7 @@
}
@override
- String get type => 'Obj';
+ String get type => 'Object';
@override
Map<String, dynamic> toJson() {
@@ -6500,7 +6502,7 @@
}
@override
- String get type => 'ScriptRef';
+ String get type => '@Script';
@override
Map<String, dynamic> toJson() {
@@ -7186,7 +7188,7 @@
}
@override
- String get type => 'TypeArgumentsRef';
+ String get type => '@TypeArguments';
@override
Map<String, dynamic> toJson() {
@@ -7388,7 +7390,7 @@
}
@override
- String get type => 'VMRef';
+ String get type => '@VM';
@override
Map<String, dynamic> toJson() {
diff --git a/pkg/vm_service/pubspec.yaml b/pkg/vm_service/pubspec.yaml
index 77a68c4..84a7fe1 100644
--- a/pkg/vm_service/pubspec.yaml
+++ b/pkg/vm_service/pubspec.yaml
@@ -3,7 +3,7 @@
A library to communicate with a service implementing the Dart VM
service protocol.
-version: 6.0.0-nullsafety.1
+version: 6.0.0-nullsafety.3
homepage: https://github.com/dart-lang/sdk/tree/master/pkg/vm_service
diff --git a/pkg/vm_service/test/invoke_test.dart b/pkg/vm_service/test/invoke_test.dart
index b928130..6458f97d 100644
--- a/pkg/vm_service/test/invoke_test.dart
+++ b/pkg/vm_service/test/invoke_test.dart
@@ -72,7 +72,7 @@
expectError(func) async {
dynamic result = await func();
- expect(result.type == 'Error' || result.type == 'ErrorRef', isTrue);
+ expect(result.type == 'Error' || result.type == '@Error', isTrue);
}
main([args = const <String>[]]) =>
diff --git a/pkg/vm_service/test/regress_44588_test.dart b/pkg/vm_service/test/regress_44588_test.dart
new file mode 100644
index 0000000..3469305
--- /dev/null
+++ b/pkg/vm_service/test/regress_44588_test.dart
@@ -0,0 +1,27 @@
+// 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.
+
+import 'package:vm_service/vm_service.dart';
+import 'package:test/test.dart';
+
+import 'common/test_helper.dart';
+
+class Foo {
+ static Bar b = Bar();
+}
+
+class Bar {}
+
+var tests = <IsolateTest>[
+ (VmService service, IsolateRef isolate) async {
+ final classes = (await service.getClassList(isolate.id!)).classes!;
+ final fooRef = classes.firstWhere((element) => element.name == 'Foo');
+ final foo = (await service.getObject(isolate.id!, fooRef.id!)) as Class;
+ final field =
+ (await service.getObject(isolate.id!, foo.fields!.first.id!)) as Field;
+ expect(field.staticValue!.valueAsString, '<not initialized>');
+ }
+];
+
+main([args = const <String>[]]) => runIsolateTests(args, tests);
diff --git a/pkg/vm_service/tool/dart/generate_dart.dart b/pkg/vm_service/tool/dart/generate_dart.dart
index 2f812ff..6f5fca6 100644
--- a/pkg/vm_service/tool/dart/generate_dart.dart
+++ b/pkg/vm_service/tool/dart/generate_dart.dart
@@ -1671,7 +1671,7 @@
} else {
if (isResponse) {
gen.writeln('@override');
- gen.writeln("String get type => '$name';");
+ gen.writeln("String get type => '$rawName';");
gen.writeln();
}
diff --git a/runtime/observatory/tests/service/deferred_import_reload/v1/deferred.dart b/runtime/observatory/tests/service/deferred_import_reload/v1/deferred.dart
new file mode 100644
index 0000000..0cdf678
--- /dev/null
+++ b/runtime/observatory/tests/service/deferred_import_reload/v1/deferred.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2020, 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.
+
+foo() => 'apple';
diff --git a/runtime/observatory/tests/service/deferred_import_reload/v1/main.dart b/runtime/observatory/tests/service/deferred_import_reload/v1/main.dart
new file mode 100644
index 0000000..3f1912e
--- /dev/null
+++ b/runtime/observatory/tests/service/deferred_import_reload/v1/main.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2020, 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:isolate';
+
+import 'deferred.dart' deferred as prefix1;
+import 'deferred.dart' deferred as prefix2;
+
+main() {
+ prefix1.loadLibrary();
+ RawReceivePort keepAlive = new RawReceivePort();
+ print('spawned isolate running');
+}
+
+test() {
+ var x = "";
+
+ try {
+ x += prefix1.foo(); // Should retain loaded=true state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ x += ",";
+
+ try {
+ x += prefix2.foo(); // Should retain loaded=false state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ return x;
+}
diff --git a/runtime/observatory/tests/service/deferred_import_reload/v2/deferred.dart b/runtime/observatory/tests/service/deferred_import_reload/v2/deferred.dart
new file mode 100644
index 0000000..7a58941
--- /dev/null
+++ b/runtime/observatory/tests/service/deferred_import_reload/v2/deferred.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2020, 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.
+
+foo() => 'orange';
diff --git a/runtime/observatory/tests/service/deferred_import_reload/v2/main.dart b/runtime/observatory/tests/service/deferred_import_reload/v2/main.dart
new file mode 100644
index 0000000..2710f32
--- /dev/null
+++ b/runtime/observatory/tests/service/deferred_import_reload/v2/main.dart
@@ -0,0 +1,36 @@
+// Copyright (c) 2020, 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:isolate';
+
+import 'deferred.dart' deferred as prefix1;
+import 'deferred.dart' deferred as prefix2;
+
+main() {
+ throw "Not executed";
+}
+
+test() {
+ var x = "";
+
+ try {
+ x += prefix1.foo(); // Should retain loaded=true state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ x += ",";
+
+ try {
+ x += prefix2.foo(); // Should retain loaded=false state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ return x;
+}
diff --git a/runtime/observatory/tests/service/deferred_import_reload_test.dart b/runtime/observatory/tests/service/deferred_import_reload_test.dart
new file mode 100644
index 0000000..dccac4e
--- /dev/null
+++ b/runtime/observatory/tests/service/deferred_import_reload_test.dart
@@ -0,0 +1,78 @@
+// Copyright (c) 2020, 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.
+//
+// OtherResources=deferred_import_reload/v1/main.dart deferred_import_reload/v1/deferred.dart deferred_import_reload/v2/main.dart deferred_import_reload/v2/deferred.dart
+
+import 'test_helper.dart';
+import 'dart:async';
+import 'dart:developer';
+import 'dart:isolate' as I;
+import 'dart:io';
+import 'service_test_common.dart';
+import 'package:observatory/service.dart';
+import 'package:path/path.dart' as path;
+import 'package:test/test.dart';
+
+// Chop off the file name.
+String baseDirectory = path.dirname(Platform.script.path) + '/';
+
+Uri baseUri = Platform.script.replace(path: baseDirectory);
+Uri spawnUri =
+ baseUri.resolveUri(Uri.parse('deferred_import_reload/v1/main.dart'));
+Uri v2Uri =
+ baseUri.resolveUri(Uri.parse('deferred_import_reload/v2/main.dart'));
+
+testMain() async {
+ print(baseUri);
+ debugger(); // Stop here.
+ // Spawn the child isolate.
+ I.Isolate isolate = await I.Isolate.spawnUri(spawnUri, [], null);
+ print(isolate);
+ debugger();
+}
+
+Future<String> invokeTest(Isolate isolate) async {
+ await isolate.reload();
+ Library lib = isolate.rootLibrary;
+ await lib.load();
+ Instance result = await lib.evaluate('test()') as Instance;
+ expect(result.isString, isTrue);
+ return result.valueAsString as String;
+}
+
+var tests = <IsolateTest>[
+ // Stopped at 'debugger' statement.
+ hasStoppedAtBreakpoint,
+ // Resume the isolate into the while loop.
+ resumeIsolate,
+ // Stop at 'debugger' statement.
+ hasStoppedAtBreakpoint,
+ (Isolate mainIsolate) async {
+ // Grab the VM.
+ VM vm = mainIsolate.vm;
+ await vm.reloadIsolates();
+ expect(vm.isolates.length, 2);
+
+ // Find the spawned isolate.
+ Isolate spawnedIsolate =
+ vm.isolates.firstWhere((Isolate i) => i != mainIsolate);
+ expect(spawnedIsolate, isNotNull);
+
+ // Invoke test in v1.
+ String v1 = await invokeTest(spawnedIsolate);
+ expect(v1, 'apple,error');
+
+ // Reload to v2.
+ var response = await spawnedIsolate.reloadSources(
+ rootLibUri: v2Uri.toString(),
+ );
+ // Observe that it succeed.
+ expect(response['success'], isTrue);
+
+ String v2 = await invokeTest(spawnedIsolate);
+ expect(v2, 'orange,error');
+ }
+];
+
+main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);
diff --git a/runtime/observatory/tests/service/service_kernel.status b/runtime/observatory/tests/service/service_kernel.status
index aa7899e..4fc37a9 100644
--- a/runtime/observatory/tests/service/service_kernel.status
+++ b/runtime/observatory/tests/service/service_kernel.status
@@ -88,6 +88,7 @@
debugger_location_test: SkipByDesign # Debugger is disabled in AOT mode.
debugging_inlined_finally_test: SkipByDesign # Debugger is disabled in AOT mode.
debugging_test: SkipByDesign # Debugger is disabled in AOT mode.
+deferred_import_reload_test: SkipByDesign # Hot reload is disabled in AOT mode.
dev_fs_spawn_test: SkipByDesign # Debugger is disabled in AOT mode.
developer_extension_test: SkipByDesign # Debugger is disabled in AOT mode.
developer_service_get_isolate_id_test: SkipByDesign # Debugger is disabled in AOT mode.
@@ -167,7 +168,7 @@
regress_28443_test: SkipByDesign # Debugger is disabled in AOT mode.
regress_28980_test: SkipByDesign # Debugger is disabled in AOT mode.
regress_34841_test: SkipByDesign # Debugger is disabled in AOT mode.
-reload_sources_test: SkipByDesign # Debugger is disabled in AOT mode.
+reload_sources_test: SkipByDesign # Hot reload is disabled in AOT mode.
rewind_optimized_out_test: SkipByDesign # Debugger is disabled in AOT mode.
rewind_test: SkipByDesign # Debugger is disabled in AOT mode.
set_library_debuggable_test: SkipByDesign # Debugger is disabled in AOT mode.
diff --git a/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/deferred.dart b/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/deferred.dart
new file mode 100644
index 0000000..0cdf678
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/deferred.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2020, 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.
+
+foo() => 'apple';
diff --git a/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/main.dart b/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/main.dart
new file mode 100644
index 0000000..3f1912e
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/deferred_import_reload/v1/main.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2020, 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:isolate';
+
+import 'deferred.dart' deferred as prefix1;
+import 'deferred.dart' deferred as prefix2;
+
+main() {
+ prefix1.loadLibrary();
+ RawReceivePort keepAlive = new RawReceivePort();
+ print('spawned isolate running');
+}
+
+test() {
+ var x = "";
+
+ try {
+ x += prefix1.foo(); // Should retain loaded=true state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ x += ",";
+
+ try {
+ x += prefix2.foo(); // Should retain loaded=false state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ return x;
+}
diff --git a/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/deferred.dart b/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/deferred.dart
new file mode 100644
index 0000000..7a58941
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/deferred.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2020, 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.
+
+foo() => 'orange';
diff --git a/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/main.dart b/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/main.dart
new file mode 100644
index 0000000..2710f32
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/deferred_import_reload/v2/main.dart
@@ -0,0 +1,36 @@
+// Copyright (c) 2020, 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:isolate';
+
+import 'deferred.dart' deferred as prefix1;
+import 'deferred.dart' deferred as prefix2;
+
+main() {
+ throw "Not executed";
+}
+
+test() {
+ var x = "";
+
+ try {
+ x += prefix1.foo(); // Should retain loaded=true state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ x += ",";
+
+ try {
+ x += prefix2.foo(); // Should retain loaded=false state across reload.
+ } catch (e, st) {
+ print(e);
+ print(st);
+ x += "error";
+ }
+
+ return x;
+}
diff --git a/runtime/observatory_2/tests/service_2/deferred_import_reload_test.dart b/runtime/observatory_2/tests/service_2/deferred_import_reload_test.dart
new file mode 100644
index 0000000..fe3bff9
--- /dev/null
+++ b/runtime/observatory_2/tests/service_2/deferred_import_reload_test.dart
@@ -0,0 +1,78 @@
+// Copyright (c) 2020, 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.
+//
+// OtherResources=deferred_import_reload/v1/main.dart deferred_import_reload/v1/deferred.dart deferred_import_reload/v2/main.dart deferred_import_reload/v2/deferred.dart
+
+import 'test_helper.dart';
+import 'dart:async';
+import 'dart:developer';
+import 'dart:isolate' as I;
+import 'dart:io';
+import 'service_test_common.dart';
+import 'package:observatory_2/service.dart';
+import 'package:path/path.dart' as path;
+import 'package:test/test.dart';
+
+// Chop off the file name.
+String baseDirectory = path.dirname(Platform.script.path) + '/';
+
+Uri baseUri = Platform.script.replace(path: baseDirectory);
+Uri spawnUri =
+ baseUri.resolveUri(Uri.parse('deferred_import_reload/v1/main.dart'));
+Uri v2Uri =
+ baseUri.resolveUri(Uri.parse('deferred_import_reload/v2/main.dart'));
+
+testMain() async {
+ print(baseUri);
+ debugger(); // Stop here.
+ // Spawn the child isolate.
+ I.Isolate isolate = await I.Isolate.spawnUri(spawnUri, [], null);
+ print(isolate);
+ debugger();
+}
+
+Future<String> invokeTest(Isolate isolate) async {
+ await isolate.reload();
+ Library lib = isolate.rootLibrary;
+ await lib.load();
+ Instance result = await lib.evaluate('test()');
+ expect(result.isString, isTrue);
+ return result.valueAsString;
+}
+
+var tests = <IsolateTest>[
+ // Stopped at 'debugger' statement.
+ hasStoppedAtBreakpoint,
+ // Resume the isolate into the while loop.
+ resumeIsolate,
+ // Stop at 'debugger' statement.
+ hasStoppedAtBreakpoint,
+ (Isolate mainIsolate) async {
+ // Grab the VM.
+ VM vm = mainIsolate.vm;
+ await vm.reloadIsolates();
+ expect(vm.isolates.length, 2);
+
+ // Find the spawned isolate.
+ Isolate spawnedIsolate =
+ vm.isolates.firstWhere((Isolate i) => i != mainIsolate);
+ expect(spawnedIsolate, isNotNull);
+
+ // Invoke test in v1.
+ String v1 = await invokeTest(spawnedIsolate);
+ expect(v1, 'apple,error');
+
+ // Reload to v2.
+ var response = await spawnedIsolate.reloadSources(
+ rootLibUri: v2Uri.toString(),
+ );
+ // Observe that it succeed.
+ expect(response['success'], isTrue);
+
+ String v2 = await invokeTest(spawnedIsolate);
+ expect(v2, 'orange,error');
+ }
+];
+
+main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);
diff --git a/runtime/observatory_2/tests/service_2/service_2_kernel.status b/runtime/observatory_2/tests/service_2/service_2_kernel.status
index cad23e2..aea3d74 100644
--- a/runtime/observatory_2/tests/service_2/service_2_kernel.status
+++ b/runtime/observatory_2/tests/service_2/service_2_kernel.status
@@ -88,6 +88,7 @@
debugger_location_test: SkipByDesign # Debugger is disabled in AOT mode.
debugging_inlined_finally_test: SkipByDesign # Debugger is disabled in AOT mode.
debugging_test: SkipByDesign # Debugger is disabled in AOT mode.
+deferred_import_reload_test: SkipByDesign # Hot reload is disabled in AOT mode.
dev_fs_spawn_test: SkipByDesign # Debugger is disabled in AOT mode.
developer_extension_test: SkipByDesign # Debugger is disabled in AOT mode.
developer_service_get_isolate_id_test: SkipByDesign # Debugger is disabled in AOT mode.
@@ -166,7 +167,7 @@
regress_28443_test: SkipByDesign # Debugger is disabled in AOT mode.
regress_28980_test: SkipByDesign # Debugger is disabled in AOT mode.
regress_34841_test: SkipByDesign # Debugger is disabled in AOT mode.
-reload_sources_test: SkipByDesign # Debugger is disabled in AOT mode.
+reload_sources_test: SkipByDesign # Hot reload is disabled in AOT mode.
rewind_optimized_out_test: SkipByDesign # Debugger is disabled in AOT mode.
rewind_test: SkipByDesign # Debugger is disabled in AOT mode.
set_library_debuggable_test: SkipByDesign # Debugger is disabled in AOT mode.
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index b6ee854..cc14ad3 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -1126,7 +1126,6 @@
ErrorPtr ClassFinalizer::LoadClassMembers(const Class& cls) {
ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
- ASSERT(Thread::Current()->IsMutatorThread());
ASSERT(!cls.is_finalized());
LongJumpScope jump;
@@ -1663,6 +1662,7 @@
#else
auto const thread = Thread::Current();
auto const isolate_group = thread->isolate_group();
+ SafepointWriteRwLocker ml(thread, isolate_group->program_lock());
StackZone stack_zone(thread);
HANDLESCOPE(thread);
auto const zone = thread->zone();
diff --git a/runtime/vm/class_table.cc b/runtime/vm/class_table.cc
index a2a1b66..ac501cf 100644
--- a/runtime/vm/class_table.cc
+++ b/runtime/vm/class_table.cc
@@ -523,7 +523,7 @@
object->AddProperty("type", "ClassList");
{
JSONArray members(object, "classes");
- for (intptr_t i = 1; i < top_; i++) {
+ for (intptr_t i = ClassId::kObjectCid; i < top_; i++) {
if (HasValidClassAt(i)) {
cls = At(i);
members.AddValue(cls);
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index 134b26b..12ec76e 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -741,17 +741,17 @@
func ^= refs.At(i);
code = func.CurrentCode();
if (func.HasCode() && !code.IsDisabled()) {
- func.SetInstructions(code); // Set entrypoint.
+ func.SetInstructionsSafe(code); // Set entrypoint.
func.SetWasCompiled(true);
} else {
- func.ClearCode(); // Set code and entrypoint to lazy compile stub.
+ func.ClearCodeSafe(); // Set code and entrypoint to lazy compile stub
}
}
} else {
Function& func = Function::Handle(d->zone());
for (intptr_t i = start_index_; i < stop_index_; i++) {
func ^= refs.At(i);
- func.ClearCode(); // Set code and entrypoint to lazy compile stub.
+ func.ClearCodeSafe(); // Set code and entrypoint to lazy compile stub.
}
}
}
diff --git a/runtime/vm/compilation_trace.cc b/runtime/vm/compilation_trace.cc
index 3aa1561..7afcf22 100644
--- a/runtime/vm/compilation_trace.cc
+++ b/runtime/vm/compilation_trace.cc
@@ -958,6 +958,8 @@
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();
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index dfa42c7..28b5d0f 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -300,8 +300,12 @@
IG->object_store()->set_##member(stub_code);
OBJECT_STORE_STUB_CODE_LIST(DO)
#undef DO
- stub_code =
- StubCode::GetBuildMethodExtractorStub(global_object_pool_builder());
+
+ {
+ SafepointWriteRwLocker ml(T, T->isolate_group()->program_lock());
+ stub_code = StubCode::GetBuildMethodExtractorStub(
+ global_object_pool_builder());
+ }
IG->object_store()->set_build_method_extractor_code(stub_code);
}
@@ -2519,6 +2523,8 @@
const auto pool_attachment = FLAG_use_bare_instructions
? Code::PoolAttachment::kNotAttachPool
: Code::PoolAttachment::kAttachPool;
+
+ SafepointWriteRwLocker ml(T, T->isolate_group()->program_lock());
const Code& code = Code::Handle(
Code::FinalizeCodeAndNotify(function, graph_compiler, assembler,
pool_attachment, optimized(), stats));
diff --git a/runtime/vm/compiler/backend/il_test_helper.cc b/runtime/vm/compiler/backend/il_test_helper.cc
index f552aff..ab32cd4 100644
--- a/runtime/vm/compiler/backend/il_test_helper.cc
+++ b/runtime/vm/compiler/backend/il_test_helper.cc
@@ -171,8 +171,13 @@
const auto& deopt_info_array =
Array::Handle(zone, graph_compiler.CreateDeoptInfo(&assembler));
const auto pool_attachment = Code::PoolAttachment::kAttachPool;
- const auto& code = Code::Handle(Code::FinalizeCode(
- &graph_compiler, &assembler, pool_attachment, optimized, nullptr));
+ Code& code = Code::Handle();
+ {
+ SafepointWriteRwLocker ml(thread_,
+ thread_->isolate_group()->program_lock());
+ code ^= Code::FinalizeCode(&graph_compiler, &assembler, pool_attachment,
+ optimized, nullptr);
+ }
code.set_is_optimized(optimized);
code.set_owner(function_);
@@ -186,11 +191,15 @@
graph_compiler.FinalizeStaticCallTargetsTable(code);
graph_compiler.FinalizeCodeSourceMap(code);
- if (optimized) {
- function_.InstallOptimizedCode(code);
- } else {
- function_.set_unoptimized_code(code);
- function_.AttachCode(code);
+ {
+ SafepointWriteRwLocker ml(thread_,
+ thread_->isolate_group()->program_lock());
+ if (optimized) {
+ function_.InstallOptimizedCode(code);
+ } else {
+ function_.set_unoptimized_code(code);
+ function_.AttachCode(code);
+ }
}
// We expect there to be no deoptimizations.
diff --git a/runtime/vm/compiler/call_specializer.cc b/runtime/vm/compiler/call_specializer.cc
index 2c4b6b0..b6f5265 100644
--- a/runtime/vm/compiler/call_specializer.cc
+++ b/runtime/vm/compiler/call_specializer.cc
@@ -805,6 +805,9 @@
// Non-implicit setter are inlined like normal method calls.
return false;
}
+ if (!CompilerState::Current().is_aot() && !target.WasCompiled()) {
+ return false;
+ }
Field& field = Field::ZoneHandle(Z, target.accessor_field());
ASSERT(!field.IsNull());
if (should_clone_fields_) {
@@ -967,6 +970,9 @@
// inlining in FlowGraphInliner.
return false;
}
+ if (!CompilerState::Current().is_aot() && !target.WasCompiled()) {
+ return false;
+ }
return TryInlineImplicitInstanceGetter(call);
}
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index ce1f9bc..44237ab4 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -925,8 +925,13 @@
} else {
#if !defined(TARGET_ARCH_IA32)
if (I != Dart::vm_isolate()) {
- IG->object_store()->set_build_method_extractor_code(
- Code::Handle(StubCode::GetBuildMethodExtractorStub(nullptr)));
+ if (IG->object_store()->build_method_extractor_code() != nullptr) {
+ SafepointWriteRwLocker ml(T, IG->program_lock());
+ if (IG->object_store()->build_method_extractor_code() != nullptr) {
+ IG->object_store()->set_build_method_extractor_code(
+ Code::Handle(StubCode::GetBuildMethodExtractorStub(nullptr)));
+ }
+ }
}
#endif // !defined(TARGET_ARCH_IA32)
}
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 35356fa..36e4687 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -6854,10 +6854,12 @@
Class::Handle(zone, core_lib.LookupClassAllowPrivate(Symbols::_RegExp()));
ASSERT(!reg_exp_class.IsNull());
+ auto thread = Thread::Current();
Function& func = Function::Handle(
zone, reg_exp_class.LookupFunctionAllowPrivate(execute_match_name));
ASSERT(!func.IsNull());
Code& code = Code::Handle(zone);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
if (func.HasCode()) {
code = func.CurrentCode();
ASSERT(!code.IsNull());
diff --git a/runtime/vm/deferred_objects.cc b/runtime/vm/deferred_objects.cc
index eddfb5e..6452f3f 100644
--- a/runtime/vm/deferred_objects.cc
+++ b/runtime/vm/deferred_objects.cc
@@ -152,6 +152,7 @@
Function& function = Function::Handle(zone);
function ^= deopt_context->ObjectAt(index_);
ASSERT(!function.IsNull());
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Error& error =
Error::Handle(zone, Compiler::EnsureUnoptimizedCode(thread, function));
if (!error.IsNull()) {
diff --git a/runtime/vm/field_table.cc b/runtime/vm/field_table.cc
index 42aef79..f045860 100644
--- a/runtime/vm/field_table.cc
+++ b/runtime/vm/field_table.cc
@@ -54,7 +54,6 @@
bool FieldTable::Register(const Field& field, intptr_t expected_field_id) {
DEBUG_ASSERT(
IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
- ASSERT(Thread::Current()->IsMutatorThread());
ASSERT(is_ready_to_use_);
if (free_head_ < 0) {
diff --git a/runtime/vm/isolate_reload.cc b/runtime/vm/isolate_reload.cc
index 21ffcf2..3d6a284 100644
--- a/runtime/vm/isolate_reload.cc
+++ b/runtime/vm/isolate_reload.cc
@@ -398,6 +398,8 @@
} else if (obj.IsClosure()) {
return String::HashRawSymbol(
Function::Handle(Closure::Cast(obj).function()).name());
+ } else if (obj.IsLibraryPrefix()) {
+ return String::HashRawSymbol(LibraryPrefix::Cast(obj).name());
} else {
FATAL1("Unexpected type in become: %s\n", obj.ToCString());
}
@@ -2078,13 +2080,15 @@
Zone* zone,
const GrowableArray<const Function*>& functions) {
TIMELINE_SCOPE(InvalidateFunctions);
- HANDLESCOPE(Thread::Current());
+ auto thread = Thread::Current();
+ HANDLESCOPE(thread);
CallSiteResetter resetter(zone);
Class& owning_class = Class::Handle(zone);
Library& owning_lib = Library::Handle(zone);
Code& code = Code::Handle(zone);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
for (intptr_t i = 0; i < functions.length(); i++) {
const Function& func = *functions[i];
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 4990754..fae18df 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -2909,7 +2909,6 @@
const intptr_t len = value.Length();
#if defined(DEBUG)
Thread* thread = Thread::Current();
- ASSERT(thread->IsMutatorThread());
ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
if (is_finalized()) {
Function& function = Function::Handle();
@@ -3807,7 +3806,6 @@
void Class::Finalize() const {
auto thread = Thread::Current();
auto isolate_group = thread->isolate_group();
- ASSERT(thread->IsMutatorThread());
ASSERT(!thread->isolate()->all_classes_finalized());
ASSERT(!is_finalized());
// Prefinalized classes have a VM internal representation and no Dart fields.
@@ -3898,15 +3896,8 @@
}
void Class::DisableCHAOptimizedCode(const Class& subclass) {
- Thread* thread = Thread::Current();
- ASSERT(thread->IsMutatorThread());
- // TODO(dartbug.com/36097): The program_lock acquisition has to move up the
- // call chain to ClassFinalizer::AllocateFinalizeClass() so that:
- // - no two threads allocate-finalize a class at the same time(we should
- // use the logic similar to what is used in EnsureIsAllocateFinalized()).
- // - code is deoptimized before we violate optimization assumptions
- // potentially done concurrently (AddDirectSubclass/AddDirectImplementor).
- SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
CHACodeArray a(*this);
if (FLAG_trace_deoptimization && a.HasCodes()) {
if (subclass.IsNull()) {
@@ -4286,16 +4277,11 @@
if (is_finalized()) {
return Error::null();
}
- if (Compiler::IsBackgroundCompilation()) {
- Compiler::AbortBackgroundCompilation(DeoptId::kNone,
- "Class finalization while compiling");
- }
SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
if (is_finalized()) {
return Error::null();
}
LeaveCompilerScope ncs(thread);
- ASSERT(thread->IsMutatorThread());
ASSERT(thread != NULL);
const Error& error =
Error::Handle(thread->zone(), ClassFinalizer::LoadClassMembers(*this));
@@ -4316,15 +4302,10 @@
if (is_allocate_finalized()) {
return Error::null();
}
- if (Compiler::IsBackgroundCompilation()) {
- Compiler::AbortBackgroundCompilation(
- DeoptId::kNone, "Class allocate finalization while compiling");
- }
SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
if (is_allocate_finalized()) {
return Error::null();
}
- ASSERT(thread->IsMutatorThread());
ASSERT(thread != NULL);
Error& error = Error::Handle(thread->zone(), EnsureIsFinalized(thread));
if (!error.IsNull()) {
@@ -4346,7 +4327,6 @@
ASSERT(!value.IsNull());
#if defined(DEBUG)
Thread* thread = Thread::Current();
- ASSERT(thread->IsMutatorThread());
ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
// Verify that all the fields in the array have this class as owner.
Field& field = Field::Handle();
@@ -4364,7 +4344,6 @@
void Class::AddField(const Field& field) const {
#if defined(DEBUG)
Thread* thread = Thread::Current();
- ASSERT(thread->IsMutatorThread());
ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
#endif
const Array& arr = Array::Handle(fields());
@@ -4376,7 +4355,6 @@
void Class::AddFields(const GrowableArray<const Field*>& new_fields) const {
#if defined(DEBUG)
Thread* thread = Thread::Current();
- ASSERT(thread->IsMutatorThread());
ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
#endif
const intptr_t num_new_fields = new_fields.length();
@@ -5063,6 +5041,14 @@
}
void Class::DisableAllocationStub() const {
+ {
+ const Code& existing_stub = Code::Handle(allocation_stub());
+ if (existing_stub.IsNull()) {
+ return;
+ }
+ }
+ auto thread = Thread::Current();
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& existing_stub = Code::Handle(allocation_stub());
if (existing_stub.IsNull()) {
return;
@@ -6695,7 +6681,7 @@
}
void Function::InstallOptimizedCode(const Code& code) const {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
// We may not have previous code if FLAG_precompile is set.
// Hot-reload may have already disabled the current code.
if (HasCode() && !Code::Handle(CurrentCode()).IsDisabled()) {
@@ -6705,8 +6691,14 @@
}
void Function::SetInstructions(const Code& value) const {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
- SetInstructionsSafe(value);
+ // Ensure that nobody is executing this function when we install it.
+ if (untag()->code() != Code::null() && HasCode()) {
+ SafepointOperationScope safepoint(Thread::Current());
+ SetInstructionsSafe(value);
+ } else {
+ ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ SetInstructionsSafe(value);
+ }
}
void Function::SetInstructionsSafe(const Code& value) const {
@@ -6717,7 +6709,7 @@
}
void Function::AttachCode(const Code& value) const {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
// Finish setting up code before activating it.
value.set_owner(*this);
SetInstructions(value);
@@ -6741,11 +6733,19 @@
#if defined(DART_PRECOMPILED_RUNTIME)
UNREACHABLE();
#else
- ASSERT(Thread::Current()->IsMutatorThread());
+ ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ untag()->set_unoptimized_code(Code::null());
+ SetInstructions(StubCode::LazyCompile());
+#endif // defined(DART_PRECOMPILED_RUNTIME)
+}
+void Function::ClearCodeSafe() const {
+#if defined(DART_PRECOMPILED_RUNTIME)
+ UNREACHABLE();
+#else
untag()->set_unoptimized_code(Code::null());
- SetInstructions(StubCode::LazyCompile());
+ SetInstructionsSafe(StubCode::LazyCompile());
#endif // defined(DART_PRECOMPILED_RUNTIME)
}
@@ -6766,9 +6766,10 @@
void Function::SwitchToUnoptimizedCode() const {
ASSERT(HasOptimizedCode());
Thread* thread = Thread::Current();
+ DEBUG_ASSERT(
+ thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
Isolate* isolate = thread->isolate();
Zone* zone = thread->zone();
- ASSERT(thread->IsMutatorThread());
// TODO(35224): DEBUG_ASSERT(thread->TopErrorHandlerIsExitFrame());
const Code& current_code = Code::Handle(zone, CurrentCode());
@@ -10065,6 +10066,23 @@
&untag()->guarded_cid_);
}
+bool Field::is_nullable(bool silence_assert) const {
+#if defined(DEBUG)
+ if (!silence_assert) {
+ // Same assert as guarded_cid(), because is_nullable() also needs to be
+ // consistent for the background compiler.
+ Thread* thread = Thread::Current();
+ ASSERT(
+ !thread->IsInsideCompiler() ||
+#if !defined(DART_PRECOMPILED_RUNTIME)
+ ((CompilerState::Current().should_clone_fields() == !IsOriginal())) ||
+#endif
+ is_static());
+ }
+#endif
+ return untag()->is_nullable_ == kNullCid;
+}
+
void Field::SetOriginal(const Field& value) const {
ASSERT(value.IsOriginal());
ASSERT(!value.IsNull());
@@ -10210,9 +10228,7 @@
return PatchClass::Cast(obj).library_kernel_offset();
}
-// Called at finalization time
-void Field::SetFieldType(const AbstractType& value) const {
- ASSERT(Thread::Current()->IsMutatorThread());
+void Field::SetFieldTypeSafe(const AbstractType& value) const {
ASSERT(IsOriginal());
ASSERT(!value.IsNull());
if (value.ptr() != type()) {
@@ -10220,6 +10236,13 @@
}
}
+// Called at finalization time
+void Field::SetFieldType(const AbstractType& value) const {
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ SetFieldTypeSafe(value);
+}
+
FieldPtr Field::New() {
ASSERT(Object::field_class() != Class::null());
ObjectPtr raw =
@@ -10241,7 +10264,7 @@
result.set_name(name);
result.set_is_static(is_static);
if (is_static) {
- result.set_field_id(-1);
+ result.set_field_id_unsafe(-1);
} else {
result.SetOffset(0, 0);
}
@@ -10249,12 +10272,12 @@
result.set_is_const(is_const);
result.set_is_reflectable(is_reflectable);
result.set_is_late(is_late);
- result.set_is_double_initialized(false);
+ result.set_is_double_initialized_unsafe(false);
result.set_owner(owner);
result.set_token_pos(token_pos);
result.set_end_token_pos(end_token_pos);
- result.set_has_nontrivial_initializer(false);
- result.set_has_initializer(false);
+ result.set_has_nontrivial_initializer_unsafe(false);
+ result.set_has_initializer_unsafe(false);
if (FLAG_precompiled_mode) {
// May be updated by KernelLoader::ReadInferredType
result.set_is_unboxing_candidate_unsafe(false);
@@ -10307,7 +10330,7 @@
const Field& result = Field::Handle(Field::New());
InitializeNew(result, name, is_static, is_final, is_const, is_reflectable,
is_late, owner, token_pos, end_token_pos);
- result.SetFieldType(type);
+ result.SetFieldTypeSafe(type);
return result.ptr();
}
@@ -10374,7 +10397,6 @@
}
void Field::set_guarded_list_length_unsafe(intptr_t list_length) const {
- ASSERT(Thread::Current()->IsMutatorThread());
ASSERT(IsOriginal());
untag()->set_guarded_list_length(Smi::New(list_length));
}
@@ -10385,7 +10407,6 @@
void Field::set_guarded_list_length_in_object_offset_unsafe(
intptr_t list_length_offset) const {
- ASSERT(Thread::Current()->IsMutatorThread());
ASSERT(IsOriginal());
StoreNonPointer(&untag()->guarded_list_length_in_object_offset_,
static_cast<int8_t>(list_length_offset - kHeapObjectTag));
@@ -16430,7 +16451,9 @@
PoolAttachment pool_attachment,
bool optimized,
CodeStatistics* stats) {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ auto thread = Thread::Current();
+ ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
+
const auto& code = Code::Handle(
FinalizeCode(compiler, assembler, pool_attachment, optimized, stats));
NotifyCodeObservers(function, code, optimized);
@@ -16443,7 +16466,9 @@
PoolAttachment pool_attachment,
bool optimized,
CodeStatistics* stats) {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ auto thread = Thread::Current();
+ ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
+
const auto& code = Code::Handle(
FinalizeCode(compiler, assembler, pool_attachment, optimized, stats));
NotifyCodeObservers(name, code, optimized);
@@ -16460,7 +16485,8 @@
PoolAttachment pool_attachment,
bool optimized,
CodeStatistics* stats /* = nullptr */) {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ auto thread = Thread::Current();
+ ASSERT(thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
ASSERT(assembler != NULL);
ObjectPool& object_pool = ObjectPool::Handle();
@@ -16514,7 +16540,6 @@
// Set pointer offsets list in Code object and resolve all handles in
// the instruction stream to raw objects.
- Thread* thread = Thread::Current();
for (intptr_t i = 0; i < pointer_offsets.length(); i++) {
intptr_t offset_in_instrs = pointer_offsets[i];
code.SetPointerOffsetAt(i, offset_in_instrs);
@@ -16797,7 +16822,7 @@
}
void Code::DisableDartCode() const {
- DEBUG_ASSERT(IsMutatorOrAtSafepoint());
+ SafepointOperationScope safepoint(Thread::Current());
ASSERT(IsFunctionCode());
ASSERT(instructions() == active_instructions());
const Code& new_code = StubCode::FixCallersTarget();
@@ -16806,7 +16831,7 @@
}
void Code::DisableStubCode() const {
- ASSERT(Thread::Current()->IsMutatorThread());
+ SafepointOperationScope safepoint(Thread::Current());
ASSERT(IsAllocationStubCode());
ASSERT(instructions() == active_instructions());
const Code& new_code = StubCode::FixAllocationStubTarget();
@@ -16833,7 +16858,16 @@
#if defined(DART_PRECOMPILED_RUNTIME)
UNREACHABLE();
#else
- DEBUG_ASSERT(IsMutatorOrAtSafepoint() || !is_alive());
+ ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ SetActiveInstructionsSafe(instructions, unchecked_offset);
+#endif
+}
+
+void Code::SetActiveInstructionsSafe(const Instructions& instructions,
+ uint32_t unchecked_offset) const {
+#if defined(DART_PRECOMPILED_RUNTIME)
+ UNREACHABLE();
+#else
// RawInstructions are never allocated in New space and hence a
// store buffer update is not needed here.
untag()->set_active_instructions(instructions.ptr());
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 1a7e62d..3c228c3 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2600,7 +2600,9 @@
void InstallOptimizedCode(const Code& code) const;
void AttachCode(const Code& value) const;
void SetInstructions(const Code& value) const;
+ void SetInstructionsSafe(const Code& value) const;
void ClearCode() const;
+ void ClearCodeSafe() const;
// Disables optimized code and switches to unoptimized code.
void SwitchToUnoptimizedCode() const;
@@ -3723,7 +3725,6 @@
void set_parameter_names(const Array& value) const;
void set_parameter_types(const Array& value) const;
void set_ic_data_array(const Array& value) const;
- void SetInstructionsSafe(const Code& value) const;
void set_name(const String& value) const;
void set_kind(UntaggedFunction::Kind value) const;
void set_parent_function(const Function& value) const;
@@ -3888,13 +3889,18 @@
}
// Called in parser after allocating field, immutable property otherwise.
// Marks fields that are initialized with a simple double constant.
- void set_is_double_initialized(bool value) const {
- ASSERT(Thread::Current()->IsMutatorThread());
+ void set_is_double_initialized_unsafe(bool value) const {
ASSERT(IsOriginal());
// TODO(36097): Once concurrent access is possible ensure updates are safe.
set_kind_bits(DoubleInitializedBit::update(value, untag()->kind_bits_));
}
+ void set_is_double_initialized(bool value) const {
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ set_is_double_initialized_unsafe(value);
+ }
+
bool initializer_changed_after_initialization() const {
return InitializerChangedAfterInitializatonBit::decode(kind_bits());
}
@@ -3968,6 +3974,7 @@
inline intptr_t field_id() const;
inline void set_field_id(intptr_t field_id) const;
+ inline void set_field_id_unsafe(intptr_t field_id) const;
ClassPtr Owner() const;
ClassPtr Origin() const; // Either mixin class, or same as owner().
@@ -3977,6 +3984,7 @@
AbstractTypePtr type() const { return untag()->type(); }
// Used by class finalizer, otherwise initialized in constructor.
void SetFieldType(const AbstractType& value) const;
+ void SetFieldTypeSafe(const AbstractType& value) const;
DART_WARN_UNUSED_RESULT
ErrorPtr VerifyEntryPoint(EntryPointPragma kind) const;
@@ -4023,25 +4031,34 @@
return HasNontrivialInitializerBit::decode(kind_bits());
}
// Called by parser after allocating field.
- void set_has_nontrivial_initializer(bool has_nontrivial_initializer) const {
+ void set_has_nontrivial_initializer_unsafe(
+ bool has_nontrivial_initializer) const {
ASSERT(IsOriginal());
- ASSERT(Thread::Current()->IsMutatorThread());
// TODO(36097): Once concurrent access is possible ensure updates are safe.
set_kind_bits(HasNontrivialInitializerBit::update(
has_nontrivial_initializer, untag()->kind_bits_));
}
+ void set_has_nontrivial_initializer(bool has_nontrivial_initializer) const {
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ set_has_nontrivial_initializer_unsafe(has_nontrivial_initializer);
+ }
bool has_initializer() const {
return HasInitializerBit::decode(kind_bits());
}
// Called by parser after allocating field.
- void set_has_initializer(bool has_initializer) const {
+ void set_has_initializer_unsafe(bool has_initializer) const {
ASSERT(IsOriginal());
- ASSERT(Thread::Current()->IsMutatorThread());
// TODO(36097): Once concurrent access is possible ensure updates are safe.
set_kind_bits(
HasInitializerBit::update(has_initializer, untag()->kind_bits_));
}
+ void set_has_initializer(bool has_initializer) const {
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ set_has_initializer_unsafe(has_initializer);
+ }
bool has_trivial_initializer() const {
return has_initializer() && !has_nontrivial_initializer();
@@ -4167,25 +4184,13 @@
// Internally we is_nullable_ field contains either kNullCid (nullable) or
// kInvalidCid (non-nullable) instead of boolean. This is done to simplify
// guarding sequence in the generated code.
- bool is_nullable(bool silence_assert = false) const {
-#if defined(DEBUG)
- if (!silence_assert) {
- // Same assert as guarded_cid(), because is_nullable() also needs to be
- // consistent for the background compiler.
- Thread* thread = Thread::Current();
- ASSERT(!IsOriginal() || is_static() || thread->IsMutatorThread() ||
- thread->IsAtSafepoint());
- }
-#endif
- return untag()->is_nullable_ == kNullCid;
- }
+ bool is_nullable(bool silence_assert = false) const;
void set_is_nullable(bool val) const {
DEBUG_ASSERT(
IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
set_is_nullable_unsafe(val);
}
void set_is_nullable_unsafe(bool val) const {
- ASSERT(Thread::Current()->IsMutatorThread());
StoreNonPointer(&untag()->is_nullable_, val ? kNullCid : kIllegalCid);
}
static intptr_t is_nullable_offset() {
@@ -6386,7 +6391,6 @@
void Enable() const {
if (!IsDisabled()) return;
- ASSERT(Thread::Current()->IsMutatorThread());
ResetActiveInstructions();
}
@@ -6463,6 +6467,8 @@
// entry point addresses.
void SetActiveInstructions(const Instructions& instructions,
uint32_t unchecked_offset) const;
+ void SetActiveInstructionsSafe(const Instructions& instructions,
+ uint32_t unchecked_offset) const;
// Resets [active_instructions_] to its original value of [instructions_] and
// updates the cached entry point addresses to match.
@@ -11290,8 +11296,13 @@
}
void Field::set_field_id(intptr_t field_id) const {
+ DEBUG_ASSERT(
+ IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter());
+ set_field_id_unsafe(field_id);
+}
+
+void Field::set_field_id_unsafe(intptr_t field_id) const {
ASSERT(is_static());
- ASSERT(Thread::Current()->IsMutatorThread());
untag()->set_host_offset_or_field_id(Smi::New(field_id));
}
diff --git a/runtime/vm/object_reload.cc b/runtime/vm/object_reload.cc
index 0838b24..e9c33b4 100644
--- a/runtime/vm/object_reload.cc
+++ b/runtime/vm/object_reload.cc
@@ -226,7 +226,7 @@
reload_context->isolate()->group()->initial_field_table()->Free(
field.field_id());
reload_context->isolate()->field_table()->Free(field.field_id());
- field.set_field_id(old_field.field_id());
+ field.set_field_id_unsafe(old_field.field_id());
}
reload_context->AddStaticFieldMapping(old_field, field);
} else {
@@ -640,29 +640,6 @@
}
};
-class UnimplementedDeferredLibrary : public ReasonForCancelling {
- public:
- UnimplementedDeferredLibrary(Zone* zone,
- const Library& from,
- const Library& to,
- const String& name)
- : ReasonForCancelling(zone), from_(from), to_(to), name_(name) {}
-
- private:
- const Library& from_;
- const Library& to_;
- const String& name_;
-
- StringPtr ToString() {
- const String& lib_url = String::Handle(to_.url());
- from_.ToCString();
- return String::NewFormatted(
- "Reloading support for deferred loading has not yet been implemented:"
- " library '%s' has deferred import '%s'",
- lib_url.ToCString(), name_.ToCString());
- }
-};
-
// This is executed before iterating over the instances.
void Class::CheckReload(const Class& replacement,
ProgramReloadContext* context) const {
@@ -852,21 +829,36 @@
void Library::CheckReload(const Library& replacement,
ProgramReloadContext* context) const {
- // TODO(26878): If the replacement library uses deferred loading,
- // reject it. We do not yet support reloading deferred libraries.
+ // Carry over the loaded bit of any deferred prefixes.
Object& object = Object::Handle();
LibraryPrefix& prefix = LibraryPrefix::Handle();
+ LibraryPrefix& original_prefix = LibraryPrefix::Handle();
+ String& name = String::Handle();
+ String& original_name = String::Handle();
DictionaryIterator it(replacement);
while (it.HasNext()) {
object = it.GetNext();
if (!object.IsLibraryPrefix()) continue;
prefix ^= object.ptr();
- if (prefix.is_deferred_load()) {
- const String& prefix_name = String::Handle(prefix.name());
- context->group_reload_context()->AddReasonForCancelling(
- new (context->zone()) UnimplementedDeferredLibrary(
- context->zone(), *this, replacement, prefix_name));
- return;
+ if (!prefix.is_deferred_load()) continue;
+
+ name = prefix.name();
+ DictionaryIterator original_it(*this);
+ while (original_it.HasNext()) {
+ object = original_it.GetNext();
+ if (!object.IsLibraryPrefix()) continue;
+ original_prefix ^= object.ptr();
+ if (!original_prefix.is_deferred_load()) continue;
+ original_name = original_prefix.name();
+ if (!name.Equals(original_name)) continue;
+
+ if (original_prefix.is_loaded()) {
+ prefix.set_is_loaded(true);
+ }
+
+ // The old prefix may be captured in the message queue for a pending load
+ // completion. This pending load should carry to the new prefix.
+ context->AddBecomeMapping(original_prefix, prefix);
}
}
}
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 1d0c396..cad9d62 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -2729,6 +2729,8 @@
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
const Function& function = Function::Handle(CreateFunction("Test_Code"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2751,6 +2753,8 @@
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
const Function& function = Function::Handle(CreateFunction("Test_Code"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2789,6 +2793,8 @@
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
const Function& function = Function::Handle(CreateFunction("Test_Code"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2830,6 +2836,8 @@
GenerateEmbedStringInCode(&_assembler_, kHello);
const Function& function =
Function::Handle(CreateFunction("Test_EmbedStringInCode"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2854,6 +2862,8 @@
GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
const Function& function =
Function::Handle(CreateFunction("Test_EmbedSmiInCode"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2873,6 +2883,8 @@
GenerateEmbedSmiInCode(&_assembler_, kSmiTestValue);
const Function& function =
Function::Handle(CreateFunction("Test_EmbedSmiIn64BitCode"));
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
function, nullptr, &_assembler_, Code::PoolAttachment::kAttachPool));
function.AttachCode(code);
@@ -2898,6 +2910,8 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
Code::PoolAttachment::kAttachPool));
@@ -2945,6 +2959,8 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
Code::PoolAttachment::kAttachPool));
@@ -3015,6 +3031,8 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler _assembler_(&object_pool_builder);
GenerateIncrement(&_assembler_);
+ SafepointWriteRwLocker locker(thread,
+ thread->isolate_group()->program_lock());
Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
Function::Handle(CreateFunction("Test_Code")), nullptr, &_assembler_,
Code::PoolAttachment::kAttachPool));
diff --git a/runtime/vm/program_visitor.cc b/runtime/vm/program_visitor.cc
index 66c6a58..b8e3de1 100644
--- a/runtime/vm/program_visitor.cc
+++ b/runtime/vm/program_visitor.cc
@@ -1220,7 +1220,7 @@
// ProgramWalker, but as long as the deduplication process is idempotent,
// the cached entry points won't change during the second visit.
VisitCode(code_);
- function.SetInstructions(code_); // Update cached entry point.
+ function.SetInstructionsSafe(code_); // Update cached entry point.
}
void VisitCode(const Code& code) {
@@ -1231,8 +1231,8 @@
instructions_ = code.active_instructions();
instructions_ = Dedup(instructions_);
}
- code.SetActiveInstructions(instructions_,
- code.UncheckedEntryPointOffset());
+ code.SetActiveInstructionsSafe(instructions_,
+ code.UncheckedEntryPointOffset());
}
private:
@@ -1258,15 +1258,15 @@
// ProgramWalker, but as long as the deduplication process is idempotent,
// the cached entry points won't change during the second visit.
VisitCode(code_);
- function.SetInstructions(code_); // Update cached entry point.
+ function.SetInstructionsSafe(code_); // Update cached entry point.
}
void VisitCode(const Code& code) {
if (code.IsDisabled()) return;
canonical_ = Dedup(code);
instructions_ = canonical_.instructions();
- code.SetActiveInstructions(instructions_,
- code.UncheckedEntryPointOffset());
+ code.SetActiveInstructionsSafe(instructions_,
+ code.UncheckedEntryPointOffset());
code.set_instructions(instructions_);
}
diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc
index 20125f3..8ad3ca9 100644
--- a/runtime/vm/runtime_entry.cc
+++ b/runtime/vm/runtime_entry.cc
@@ -2940,7 +2940,10 @@
ASSERT(!unoptimized_code.IsNull());
// The switch to unoptimized code may have already occurred.
if (function.HasOptimizedCode()) {
- function.SwitchToUnoptimizedCode();
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+ if (function.HasOptimizedCode()) {
+ function.SwitchToUnoptimizedCode();
+ }
}
if (frame->IsMarkedForLazyDeopt()) {
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index 281b4ba4..20deaed 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -2250,8 +2250,9 @@
// Is this field static?
bool static;
- // The value of this field, if the field is static.
- @Instance staticValue [optional];
+ // The value of this field, if the field is static. If uninitialized,
+ // this will take the value of an uninitialized Sentinel.
+ @Instance|Sentinel staticValue [optional];
// The location of this field in the source code.
SourceLocation location [optional];
diff --git a/runtime/vm/stub_code.cc b/runtime/vm/stub_code.cc
index 7f09adc0..e41c642 100644
--- a/runtime/vm/stub_code.cc
+++ b/runtime/vm/stub_code.cc
@@ -69,6 +69,9 @@
const char* name,
compiler::ObjectPoolBuilder* object_pool_builder,
void (*GenerateStub)(compiler::Assembler* assembler)) {
+ auto thread = Thread::Current();
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+
compiler::Assembler assembler(object_pool_builder);
GenerateStub(&assembler);
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
@@ -188,11 +191,13 @@
Array::Handle(zone, compiler::StubCodeCompiler::BuildStaticCallsTable(
zone, &unresolved_calls));
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+
auto mutator_fun = [&]() {
stub = Code::FinalizeCode(nullptr, &assembler, pool_attachment,
/*optimized=*/false,
/*stats=*/nullptr);
- // Check if background compilation thread has not already added the stub.
+ // Check if some other thread has not already added the stub.
if (cls.allocation_stub() == Code::null()) {
stub.set_owner(cls);
if (!static_calls_table.IsNull()) {
@@ -201,32 +206,13 @@
cls.set_allocation_stub(stub);
}
};
- auto bg_compiler_fun = [&]() {
- ASSERT(Thread::Current()->IsAtSafepoint());
- stub = cls.allocation_stub();
- // Check if stub was already generated.
- if (!stub.IsNull()) {
- return;
- }
- stub = Code::FinalizeCode(nullptr, &assembler, pool_attachment,
- /*optimized=*/false, /*stats=*/nullptr);
- stub.set_owner(cls);
- if (!static_calls_table.IsNull()) {
- stub.set_static_calls_target_table(static_calls_table);
- }
- cls.set_allocation_stub(stub);
- };
// We have to ensure no mutators are running, because:
//
// a) We allocate an instructions object, which might cause us to
// temporarily flip page protections from (RX -> RW -> RX).
- //
- // b) To ensure only one thread succeeds installing an allocation for the
- // given class.
- //
- thread->isolate_group()->RunWithStoppedMutators(
- mutator_fun, bg_compiler_fun, /*use_force_growth=*/true);
+ thread->isolate_group()->RunWithStoppedMutators(mutator_fun,
+ /*use_force_growth=*/true);
// We notify code observers after finalizing the code in order to be
// outside a [SafepointOperationScope].
diff --git a/runtime/vm/stub_code_arm64_test.cc b/runtime/vm/stub_code_arm64_test.cc
index ee35305..9814bba 100644
--- a/runtime/vm/stub_code_arm64_test.cc
+++ b/runtime/vm/stub_code_arm64_test.cc
@@ -60,6 +60,7 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallRuntimeStub(&assembler, length);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
@@ -102,6 +103,7 @@
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallLeafRuntimeStub(&assembler, str_value, lhs_index_value,
rhs_index_value, length_value);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallLeafRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
diff --git a/runtime/vm/stub_code_arm_test.cc b/runtime/vm/stub_code_arm_test.cc
index f5cabff..9fee1fd 100644
--- a/runtime/vm/stub_code_arm_test.cc
+++ b/runtime/vm/stub_code_arm_test.cc
@@ -59,6 +59,7 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallRuntimeStub(&assembler, length);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
@@ -100,6 +101,7 @@
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallLeafRuntimeStub(&assembler, str_value, lhs_index_value,
rhs_index_value, length_value);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallLeafRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
diff --git a/runtime/vm/stub_code_ia32_test.cc b/runtime/vm/stub_code_ia32_test.cc
index f86f895..13473ad 100644
--- a/runtime/vm/stub_code_ia32_test.cc
+++ b/runtime/vm/stub_code_ia32_test.cc
@@ -59,6 +59,7 @@
const char* kName = "Test_CallRuntimeStubCode";
compiler::Assembler assembler(nullptr);
GenerateCallToCallRuntimeStub(&assembler, length);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
@@ -104,6 +105,7 @@
compiler::Assembler assembler(nullptr);
GenerateCallToCallLeafRuntimeStub(&assembler, str_value, lhs_index_value,
rhs_index_value, length_value);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallLeafRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
diff --git a/runtime/vm/stub_code_x64_test.cc b/runtime/vm/stub_code_x64_test.cc
index 909d124..c586af8 100644
--- a/runtime/vm/stub_code_x64_test.cc
+++ b/runtime/vm/stub_code_x64_test.cc
@@ -60,6 +60,7 @@
compiler::ObjectPoolBuilder object_pool_builder;
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallRuntimeStub(&assembler, length);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
@@ -102,6 +103,7 @@
compiler::Assembler assembler(&object_pool_builder);
GenerateCallToCallLeafRuntimeStub(&assembler, str_value, lhs_index_value,
rhs_index_value, length_value);
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
const Code& code = Code::Handle(Code::FinalizeCodeAndNotify(
*CreateFunction("Test_CallLeafRuntimeStubCode"), nullptr, &assembler,
Code::PoolAttachment::kAttachPool));
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
index 5fed5d2..686b69f 100644
--- a/runtime/vm/type_testing_stubs.cc
+++ b/runtime/vm/type_testing_stubs.cc
@@ -243,6 +243,7 @@
// a) We allocate an instructions object, which might cause us to
// temporarily flip page protections from (RX -> RW -> RX).
//
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
thread->isolate_group()->RunWithStoppedMutators(install_code_fun,
/*use_force_growth=*/true);
diff --git a/runtime/vm/unit_test.cc b/runtime/vm/unit_test.cc
index 2a2a861..e1370f8 100644
--- a/runtime/vm/unit_test.cc
+++ b/runtime/vm/unit_test.cc
@@ -654,8 +654,8 @@
#endif
void AssemblerTest::Assemble() {
- const String& function_name =
- String::ZoneHandle(Symbols::New(Thread::Current(), name_));
+ auto thread = Thread::Current();
+ const String& function_name = String::ZoneHandle(Symbols::New(thread, name_));
// We make a dummy script so that exception objects can be composed for
// assembler instructions that do runtime calls.
@@ -669,6 +669,7 @@
Function& function = Function::ZoneHandle(Function::New(
signature, function_name, UntaggedFunction::kRegularFunction, true, false,
false, false, false, cls, TokenPosition::kMinSource));
+ SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
code_ = Code::FinalizeCodeAndNotify(function, nullptr, assembler_,
Code::PoolAttachment::kAttachPool);
code_.set_owner(function);
diff --git a/sdk/BUILD.gn b/sdk/BUILD.gn
index 4214311..b6091dc 100644
--- a/sdk/BUILD.gn
+++ b/sdk/BUILD.gn
@@ -158,66 +158,24 @@
] ]
}
-_full_sdk_snapshots = [
- [
- "dart2js",
- "../utils/compiler:dart2js",
- ],
- [
- "dartanalyzer",
- "../utils/dartanalyzer:generate_dartanalyzer_snapshot",
- ],
- [
- "dartdev",
- "../utils/dartdev:generate_dartdev_snapshot",
- ],
- [
- "dartdevc",
- "../utils/dartdevc",
- ],
- [
- "dartdoc",
- "../utils/dartdoc",
- ],
- [
- "dartfmt",
- "../utils/dartfmt",
- ],
- [
- "dds",
- "../utils/dds:dds",
- ],
- [
- "kernel_worker",
- "../utils/bazel:kernel_worker",
- ],
- [
- "pub",
- "../utils/pub",
- ],
- [
- "frontend_server",
- "../utils/kernel-service:frontend_server",
- ],
-]
-if (dart_target_arch != "ia32") {
- _full_sdk_snapshots += [ [
- "dart2native",
- "../utils/dart2native:generate_dart2native_snapshot",
- ] ]
-}
-if (create_kernel_service_snapshot) {
- _full_sdk_snapshots += [ [
- "kernel-service",
- "../utils/kernel-service:kernel-service_snapshot",
- ] ]
-}
-if (dart_target_arch != "arm") {
- _full_sdk_snapshots += [ [
- "analysis_server",
- "../utils/analysis_server",
- ] ]
-}
+_full_sdk_snapshots = _platform_sdk_snapshots + [
+ [
+ "dart2js",
+ "../utils/compiler:dart2js",
+ ],
+ [
+ "dartdevc",
+ "../utils/dartdevc",
+ ],
+ [
+ "kernel_worker",
+ "../utils/bazel:kernel_worker",
+ ],
+ [
+ "frontend_server",
+ "../utils/kernel-service:frontend_server",
+ ],
+ ]
# Libraries that go under lib/
_full_sdk_libraries = [
diff --git a/tests/dart2js/late_initializers_1_test.dart b/tests/dart2js/late_initializers_1_test.dart
new file mode 100644
index 0000000..995fc30
--- /dev/null
+++ b/tests/dart2js/late_initializers_1_test.dart
@@ -0,0 +1,88 @@
+// 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.
+
+import 'package:expect/expect.dart';
+
+// Tests where late variable or field has a predictable value. An incorrect
+// optimization might try to eliminate part of the check.
+
+String lastTag = 'unset';
+
+int zero(String tag) {
+ lastTag = tag;
+ return 0;
+}
+
+int one(String tag) {
+ lastTag = tag;
+ return 1;
+}
+
+int? returnNull(String tag) {
+ lastTag = tag;
+ return null;
+}
+
+class C1 {
+ late int? i1 = zero('C1.i1');
+ late int i2 = zero('C1.i2');
+ late int? i3 = returnNull('C1.i3');
+ late int i4 = one('C1.i4');
+}
+
+class C2 {
+ late final int? i1 = zero('C2.i1');
+ late final int i2 = zero('C2.i2');
+ late final int? i3 = returnNull('C2.i3');
+ late int i4 = one('C2.i4');
+}
+
+void test1() {
+ for (int i = 0; i < 10; i++) {
+ final c = C1();
+ lastTag = '';
+ Expect.equals(0, c.i1);
+ Expect.equals('C1.i1', lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C1.i2', lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C1.i3', lastTag);
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C1.i3', lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C1.i3', lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C1.i3', lastTag);
+
+ Expect.equals(1, c.i4);
+ Expect.equals('C1.i4', lastTag);
+ }
+}
+
+void test2() {
+ final c = C2();
+ lastTag = '';
+ Expect.equals(0, c.i1);
+ Expect.equals('C2.i1', lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C2.i2', lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C2.i3', lastTag);
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C2.i3', lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C2.i3', lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C2.i3', lastTag);
+
+ Expect.equals(1, c.i4);
+ Expect.equals('C2.i4', lastTag);
+}
+
+main() {
+ test1();
+ test2();
+}
diff --git a/tests/dart2js/late_initializers_2_test.dart b/tests/dart2js/late_initializers_2_test.dart
new file mode 100644
index 0000000..9e280fc
--- /dev/null
+++ b/tests/dart2js/late_initializers_2_test.dart
@@ -0,0 +1,105 @@
+// 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.
+
+import 'package:expect/expect.dart';
+
+// Tests where late variable or field has a predictable value. An incorrect
+// optimization might try to eliminate part of the check.
+
+class C1 {
+ late String lastTag;
+
+ int zero(String tag) {
+ lastTag = tag;
+ return 0;
+ }
+
+ int one(String tag) {
+ lastTag = tag;
+ return 1;
+ }
+
+ int? returnNull(String tag) {
+ lastTag = tag;
+ return null;
+ }
+
+ late int? i1 = zero('C1.i1');
+ late int i2 = zero('C1.i2');
+ late int? i3 = returnNull('C1.i3');
+ late int i4 = one('C1.i4');
+}
+
+void test1() {
+ for (int i = 0; i < 10; i++) {
+ final c = C1();
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C1.i1', c.lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C1.i2', c.lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C1.i3', c.lastTag);
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C1.i3', c.lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C1.i3', c.lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C1.i3', c.lastTag);
+
+ Expect.equals(1, c.i4);
+ Expect.equals('C1.i4', c.lastTag);
+ }
+}
+
+class C2 {
+ late String lastTag;
+
+ int zero(String tag) {
+ lastTag = tag;
+ return 0;
+ }
+
+ int one(String tag) {
+ lastTag = tag;
+ return 1;
+ }
+
+ int? returnNull(String tag) {
+ lastTag = tag;
+ return null;
+ }
+
+ late final int? i1 = zero('C2.i1');
+ late final int i2 = zero('C2.i2');
+ late final int? i3 = returnNull('C2.i3');
+ late int i4 = one('C2.i4');
+}
+
+void test2() {
+ final c = C2();
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C2.i1', c.lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C2.i2', c.lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C2.i3', c.lastTag);
+
+ Expect.equals(0, c.i1);
+ Expect.equals('C2.i3', c.lastTag);
+ Expect.equals(0, c.i2);
+ Expect.equals('C2.i3', c.lastTag);
+ Expect.equals(null, c.i3);
+ Expect.equals('C2.i3', c.lastTag);
+
+ Expect.equals(1, c.i4);
+ Expect.equals('C2.i4', c.lastTag);
+}
+
+main() {
+ test1();
+ test2();
+}
diff --git a/tests/language/mixin/interface_check_test.dart b/tests/language/mixin/interface_check_test.dart
index db0aaf3..9884d1b 100644
--- a/tests/language/mixin/interface_check_test.dart
+++ b/tests/language/mixin/interface_check_test.dart
@@ -19,7 +19,7 @@
class C extends A //
// ^
-// [analyzer] COMPILE_TIME_ERROR.INVALID_OVERRIDE
+// [analyzer] COMPILE_TIME_ERROR.INVALID_IMPLEMENTATION_OVERRIDE
// [cfe] The implementation of 'thing' in the non-abstract class 'C' does not conform to its interface.
with
B
diff --git a/tests/language/regress/regress31596_covariant_declaration_test.dart b/tests/language/regress/regress31596_covariant_declaration_test.dart
index 20defe2..c9c9053 100644
--- a/tests/language/regress/regress31596_covariant_declaration_test.dart
+++ b/tests/language/regress/regress31596_covariant_declaration_test.dart
@@ -18,7 +18,7 @@
class D extends C implements I {}
// ^
-// [analyzer] COMPILE_TIME_ERROR.INVALID_OVERRIDE
+// [analyzer] COMPILE_TIME_ERROR.INVALID_IMPLEMENTATION_OVERRIDE
// [cfe] unspecified
main() {}
diff --git a/tests/language_2/mixin/interface_check_test.dart b/tests/language_2/mixin/interface_check_test.dart
index db0aaf3..9884d1b 100644
--- a/tests/language_2/mixin/interface_check_test.dart
+++ b/tests/language_2/mixin/interface_check_test.dart
@@ -19,7 +19,7 @@
class C extends A //
// ^
-// [analyzer] COMPILE_TIME_ERROR.INVALID_OVERRIDE
+// [analyzer] COMPILE_TIME_ERROR.INVALID_IMPLEMENTATION_OVERRIDE
// [cfe] The implementation of 'thing' in the non-abstract class 'C' does not conform to its interface.
with
B
diff --git a/tests/language_2/regress/regress31596_covariant_declaration_test.dart b/tests/language_2/regress/regress31596_covariant_declaration_test.dart
index 20defe2..c9c9053 100644
--- a/tests/language_2/regress/regress31596_covariant_declaration_test.dart
+++ b/tests/language_2/regress/regress31596_covariant_declaration_test.dart
@@ -18,7 +18,7 @@
class D extends C implements I {}
// ^
-// [analyzer] COMPILE_TIME_ERROR.INVALID_OVERRIDE
+// [analyzer] COMPILE_TIME_ERROR.INVALID_IMPLEMENTATION_OVERRIDE
// [cfe] unspecified
main() {}
diff --git a/tests/lib/js/no_library_annotation_test.dart b/tests/lib/js/no_library_annotation_test.dart
new file mode 100644
index 0000000..24fbc57
--- /dev/null
+++ b/tests/lib/js/no_library_annotation_test.dart
@@ -0,0 +1,15 @@
+// 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.
+
+// Test that JS-interop works without a @JS annotation on the library itself.
+
+import 'package:js/js.dart';
+import 'package:expect/expect.dart';
+
+@JS()
+external dynamic eval(String code);
+
+void main() {
+ Expect.equals(2, eval("2"));
+}
diff --git a/tests/lib_2/js/no_library_annotation_test.dart b/tests/lib_2/js/no_library_annotation_test.dart
new file mode 100644
index 0000000..3e0a7af
--- /dev/null
+++ b/tests/lib_2/js/no_library_annotation_test.dart
@@ -0,0 +1,17 @@
+// 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
+
+// Test that JS-interop works without a @JS annotation on the library itself.
+
+import 'package:js/js.dart';
+import 'package:expect/expect.dart';
+
+@JS()
+external dynamic eval(String code);
+
+void main() {
+ Expect.equals(2, eval("2"));
+}
diff --git a/tools/VERSION b/tools/VERSION
index 3e628b6..b5a8ca3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 12
PATCH 0
-PRERELEASE 246
+PRERELEASE 247
PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/gn.py b/tools/gn.py
index f315ade..2af3931 100755
--- a/tools/gn.py
+++ b/tools/gn.py
@@ -212,7 +212,7 @@
gn_args['is_ubsan'] = sanitizer == 'ubsan'
gn_args['is_qemu'] = args.use_qemu
- if not args.platform_sdk and not gn_args['target_cpu'].startswith('arm'):
+ if not args.platform_sdk:
gn_args['dart_platform_sdk'] = args.platform_sdk
# We don't support stripping on Windows
