diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/type_promotion/data/implicit_downcast.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/type_promotion/data/implicit_downcast.dart
new file mode 100644
index 0000000..1c406f5
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/type_promotion/data/implicit_downcast.dart
@@ -0,0 +1,161 @@
+// 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.
+
+// The tests in this file verify that implicit downcasts *don't* cause
+// promotions.
+
+f(int i) {}
+
+assignment(int i, dynamic d) {
+  i = d;
+  d;
+}
+
+nullAwareAssignment(int i, dynamic d) {
+  i ??= d;
+  d;
+}
+
+compoundAssignment(num n, dynamic d) {
+  n += d;
+  d;
+}
+
+initialization(dynamic d) {
+  int i = d;
+  d;
+}
+
+parameter(dynamic d) {
+  f(d);
+  d;
+}
+
+ifCondition(dynamic d) {
+  if (d) {}
+  d;
+}
+
+ifCondition_then(dynamic d) {
+  if (d) {
+    d;
+  }
+}
+
+ifCondition_return(dynamic d) {
+  if (d) return;
+  d;
+}
+
+ifElementCondition(dynamic d) {
+  [if (d) null];
+  d;
+}
+
+ifElementCondition_then(dynamic d) {
+  [if (d) d];
+}
+
+forCondition(dynamic d) {
+  for (; d;) {}
+  d;
+}
+
+forCondition_body(dynamic d) {
+  for (; d;) {
+    d;
+  }
+}
+
+forElementCondition(dynamic d) {
+  [for (; d;) null];
+  d;
+}
+
+forElementCondition_body(dynamic d) {
+  [for (; d;) d];
+}
+
+forEachIterable(dynamic d) {
+  for (var item in d) {}
+  d;
+}
+
+forEachIterable_body(dynamic d) {
+  for (var item in d) {
+    d;
+  }
+}
+
+forEachElementIterable(dynamic d) {
+  [for (var item in d) null];
+  d;
+}
+
+forEachElementIterable_body(dynamic d) {
+  [for (var item in d) d];
+}
+
+whileCondition(dynamic d) {
+  while (d) {}
+  d;
+}
+
+whileCondition_body(dynamic d) {
+  while (d) {
+    d;
+  }
+}
+
+doCondition(dynamic d) {
+  do {} while (d);
+  d;
+}
+
+conditionalCondition(dynamic d) {
+  d ? null : null;
+  d;
+}
+
+conditionalCondition_thenElse(dynamic d) {
+  d ? d : d;
+}
+
+andLhs(dynamic d, bool b) {
+  d && b;
+  d;
+}
+
+andRhs(dynamic d, bool b) {
+  b && d;
+  d;
+}
+
+andBoth(dynamic d, bool b) {
+  d && d;
+}
+
+orLhs(dynamic d, bool b) {
+  d || b;
+  d;
+}
+
+orRhs(dynamic d, bool b) {
+  b || d;
+  d;
+}
+
+orBotn(dynamic d, bool b) {
+  d || d;
+}
+
+logicalNot(dynamic d, bool b) {
+  !d;
+  d;
+}
+
+await_(dynamic d) async {
+  await d;
+  d;
+}
diff --git a/pkg/analysis_server/lib/plugin/protocol/protocol_dart.dart b/pkg/analysis_server/lib/plugin/protocol/protocol_dart.dart
index f62b233..3efab8b 100644
--- a/pkg/analysis_server/lib/plugin/protocol/protocol_dart.dart
+++ b/pkg/analysis_server/lib/plugin/protocol/protocol_dart.dart
@@ -132,8 +132,13 @@
       return null;
     }
     parameters = element.parameters.toList();
-  } else if (element is engine.FunctionTypeAliasElement) {
-    parameters = element.function.parameters.toList();
+  } else if (element is engine.TypeAliasElement) {
+    var aliasedElement = element.aliasedElement;
+    if (aliasedElement is engine.GenericFunctionTypeElement) {
+      parameters = aliasedElement.parameters.toList();
+    } else {
+      return null;
+    }
   } else {
     return null;
   }
diff --git a/pkg/analysis_server/lib/src/computer/computer_highlights.dart b/pkg/analysis_server/lib/src/computer/computer_highlights.dart
index df56229..d149af1 100644
--- a/pkg/analysis_server/lib/src/computer/computer_highlights.dart
+++ b/pkg/analysis_server/lib/src/computer/computer_highlights.dart
@@ -38,7 +38,11 @@
           }
         }
         if (commentToken.type == TokenType.SINGLE_LINE_COMMENT) {
-          highlightType = HighlightRegionType.COMMENT_END_OF_LINE;
+          if (commentToken.lexeme.startsWith('///')) {
+            highlightType = HighlightRegionType.COMMENT_DOCUMENTATION;
+          } else {
+            highlightType = HighlightRegionType.COMMENT_END_OF_LINE;
+          }
         }
         if (highlightType != null) {
           _addRegion_token(commentToken, highlightType);
@@ -700,6 +704,12 @@
   }
 
   @override
+  void visitInterpolationString(InterpolationString node) {
+    computer._addRegion_node(node, HighlightRegionType.LITERAL_STRING);
+    super.visitInterpolationString(node);
+  }
+
+  @override
   void visitIsExpression(IsExpression node) {
     computer._addRegion_token(node.isOperator, HighlightRegionType.KEYWORD);
     super.visitIsExpression(node);
diff --git a/pkg/analysis_server/lib/src/lsp/constants.dart b/pkg/analysis_server/lib/src/lsp/constants.dart
index 6fea377..81468ca 100644
--- a/pkg/analysis_server/lib/src/lsp/constants.dart
+++ b/pkg/analysis_server/lib/src/lsp/constants.dart
@@ -88,8 +88,20 @@
   static const super_ = Method('dart/textDocument/super');
 
   // TODO(dantup): Remove custom AnalyzerStatus status method soon as no clients
-  // should be relying on it and we now support proper $/progress events.
+  // should be relying on it as we now support proper $/progress events.
   static const analyzerStatus = Method(r'$/analyzerStatus');
+
+  /// Semantic tokens are dynamically registered using a single string
+  /// "textDocument/semanticTokens" instead of for each individual method
+  /// (full, range, full/delta) so the built-in Method class does not contain
+  /// the required constant.
+  static const semanticTokenDynamicRegistration =
+      Method('textDocument/semanticTokens');
+}
+
+abstract class CustomSemanticTokenTypes {
+  static const annotation = SemanticTokenTypes('annotation');
+  static const boolean = SemanticTokenTypes('boolean');
 }
 
 /// CodeActionKinds supported by the server that are not declared in the LSP spec.
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_semantic_tokens.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_semantic_tokens.dart
new file mode 100644
index 0000000..7ffda4f
--- /dev/null
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_semantic_tokens.dart
@@ -0,0 +1,84 @@
+// 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:async';
+
+import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
+import 'package:analysis_server/lsp_protocol/protocol_special.dart';
+import 'package:analysis_server/src/computer/computer_highlights.dart';
+import 'package:analysis_server/src/lsp/handlers/handlers.dart';
+import 'package:analysis_server/src/lsp/lsp_analysis_server.dart';
+import 'package:analysis_server/src/lsp/mapping.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/encoder.dart';
+import 'package:analysis_server/src/plugin/result_merger.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+
+class SemanticTokensHandler
+    extends MessageHandler<SemanticTokensParams, SemanticTokens>
+    with LspPluginRequestHandlerMixin {
+  SemanticTokensHandler(LspAnalysisServer server) : super(server);
+
+  @override
+  Method get handlesMessage => Method.textDocument_semanticTokens_full;
+
+  @override
+  LspJsonHandler<SemanticTokensParams> get jsonHandler =>
+      SemanticTokensParams.jsonHandler;
+
+  List<List<HighlightRegion>> getPluginResults(String path) {
+    final notificationManager = server.notificationManager;
+    return notificationManager.highlights.getResults(path);
+  }
+
+  Future<List<HighlightRegion>> getServerResult(String path) async {
+    final result = await server.getResolvedUnit(path);
+    if (result?.state == ResultState.VALID) {
+      final computer = DartUnitHighlightsComputer(result.unit);
+      return computer.compute();
+    }
+    return [];
+  }
+
+  @override
+  Future<ErrorOr<SemanticTokens>> handle(
+      SemanticTokensParams params, CancellationToken token) async {
+    final path = pathOfDoc(params.textDocument);
+
+    return path.mapResult((path) async {
+      final lineInfo = server.getLineInfo(path);
+      // If there is no lineInfo, the request cannot be translated from LSP
+      // line/col to server offset/length.
+      if (lineInfo == null) {
+        return success(null);
+      }
+
+      // We need to be able to split multiline tokens up if a client does not
+      // support them. Doing this correctly requires access to the line endings
+      // and indenting so we must get a copy of the file contents. Although this
+      // is on the Dart unit result, we may also need this for files being
+      // handled by plugins.
+      final file = server.resourceProvider.getFile(path);
+      if (!file.exists) {
+        return success(null);
+      }
+      final fileContents = file.readAsStringSync();
+
+      final allResults = [
+        await getServerResult(path),
+        ...getPluginResults(path),
+      ];
+
+      final merger = ResultMerger();
+      final mergedResults = merger.mergeHighlightRegions(allResults);
+
+      final encoder = SemanticTokenEncoder();
+      final tokens =
+          encoder.convertHighlights(mergedResults, lineInfo, fileContents);
+      final semanticTokens = encoder.encodeTokens(tokens);
+
+      return success(semanticTokens);
+    });
+  }
+}
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_states.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_states.dart
index c1e6a39..0a7d9a6 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_states.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_states.dart
@@ -29,6 +29,7 @@
 import 'package:analysis_server/src/lsp/handlers/handler_initialized.dart';
 import 'package:analysis_server/src/lsp/handlers/handler_references.dart';
 import 'package:analysis_server/src/lsp/handlers/handler_rename.dart';
+import 'package:analysis_server/src/lsp/handlers/handler_semantic_tokens.dart';
 import 'package:analysis_server/src/lsp/handlers/handler_shutdown.dart';
 import 'package:analysis_server/src/lsp/handlers/handler_signature_help.dart';
 import 'package:analysis_server/src/lsp/handlers/handler_text_document_changes.dart';
@@ -102,6 +103,7 @@
     registerHandler(WorkspaceDidChangeConfigurationMessageHandler(server));
     registerHandler(ReanalyzeHandler(server));
     registerHandler(WillRenameFilesHandler(server));
+    registerHandler(SemanticTokensHandler(server));
   }
 }
 
diff --git a/pkg/analysis_server/lib/src/lsp/semantic_tokens/encoder.dart b/pkg/analysis_server/lib/src/lsp/semantic_tokens/encoder.dart
new file mode 100644
index 0000000..903aa12
--- /dev/null
+++ b/pkg/analysis_server/lib/src/lsp/semantic_tokens/encoder.dart
@@ -0,0 +1,195 @@
+// 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:collection';
+import 'dart:math' as math;
+
+import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/legend.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/mapping.dart';
+import 'package:analyzer/source/line_info.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+
+/// Collects information about Semantic Tokens using absolute line/columns and
+/// token types/modifiers and encodes them into a [List<int>] in a
+/// [SemanticTokens] (a [List<int>]) as described by the LSP spec .
+class SemanticTokenEncoder {
+  /// Converts [regions]s into LSP [SemanticTokenInfo], splitting multiline tokens
+  /// and nested tokens if required.
+  List<SemanticTokenInfo> convertHighlights(
+      List<HighlightRegion> regions, LineInfo lineInfo, String fileContent) {
+    // LSP is zero-based but server is 1-based.
+    const lspPositionOffset = -1;
+
+    final tokens = <SemanticTokenInfo>[];
+
+    // Capabilities exist for supporting multiline/overlapping tokens. These
+    // could be used if any clients take it up (VS Code does not).
+    // - clientCapabilities?.multilineTokenSupport
+    // - clientCapabilities?.overlappingTokenSupport
+    final allowMultilineTokens = false;
+    final allowOverlappingTokens = false;
+
+    Iterable<HighlightRegion> translatedRegions = regions;
+
+    if (!allowMultilineTokens) {
+      translatedRegions = translatedRegions.expand(
+          (region) => _splitMultilineRegions(region, lineInfo, fileContent));
+    }
+    if (!allowOverlappingTokens) {
+      translatedRegions = _splitOverlappingTokens(translatedRegions);
+    }
+
+    for (final region in translatedRegions) {
+      final tokenType = highlightRegionTokenTypes[region.type];
+      if (tokenType == null) {
+        // Skip over tokens we don't have mappings for.
+        continue;
+      }
+
+      final start = lineInfo.getLocation(region.offset);
+
+      tokens.add(SemanticTokenInfo(
+        start.lineNumber + lspPositionOffset,
+        start.columnNumber + lspPositionOffset,
+        region.length,
+        tokenType,
+        highlightRegionTokenModifiers[region.type],
+      ));
+    }
+
+    return tokens;
+  }
+
+  SemanticTokens encodeTokens(List<SemanticTokenInfo> tokens) {
+    final encodedTokens = <int>[];
+    var lastLine = 0;
+    var lastColumn = 0;
+
+    // Ensure tokens are all sorted by location in file regardless of the order
+    // they were registered.
+    tokens.sort(SemanticTokenInfo.offsetSort);
+
+    for (final token in tokens) {
+      var relativeLine = token.line - lastLine;
+      // Column is relative to last only if on the same line.
+      var relativeColumn =
+          relativeLine == 0 ? token.column - lastColumn : token.column;
+
+      // The resulting array is groups of 5 items as described in the LSP spec:
+      // https://github.com/microsoft/language-server-protocol/blob/gh-pages/_specifications/specification-3-16.md#textDocument_semanticTokens
+      encodedTokens.addAll([
+        relativeLine,
+        relativeColumn,
+        token.length,
+        semanticTokenLegend.indexForType(token.type),
+        semanticTokenLegend.bitmaskForModifiers(token.modifiers) ?? 0
+      ]);
+
+      lastLine = token.line;
+      lastColumn = token.column;
+    }
+
+    return SemanticTokens(data: encodedTokens);
+  }
+
+  /// Splits multiline regions into multiple regions for clients that do not support
+  /// multiline tokens.
+  Iterable<HighlightRegion> _splitMultilineRegions(
+      HighlightRegion region, LineInfo lineInfo, String fileContent) sync* {
+    final start = lineInfo.getLocation(region.offset);
+    final end = lineInfo.getLocation(region.offset + region.length);
+
+    // Create a region for each line in the original region.
+    for (var lineNumber = start.lineNumber;
+        lineNumber <= end.lineNumber;
+        lineNumber++) {
+      final isFirstLine = lineNumber == start.lineNumber;
+      final isLastLine = lineNumber == end.lineNumber;
+      final isSingleLine = start.lineNumber == end.lineNumber;
+      final lineOffset = lineInfo.getOffsetOfLine(lineNumber - 1);
+
+      var startOffset = isFirstLine ? start.columnNumber - 1 : 0;
+      var endOffset = isLastLine
+          ? end.columnNumber - 1
+          : lineInfo.getOffsetOfLine(lineNumber) - lineOffset;
+      var length = endOffset - startOffset;
+
+      // When we split multiline tokens, we may end up with leading/trailing
+      // whitespace which doesn't make sense to include in the token. Examine
+      // the content to remove this.
+      if (!isSingleLine) {
+        final tokenContent = fileContent.substring(
+            lineOffset + startOffset, lineOffset + endOffset);
+        final leadingWhitespaceCount =
+            tokenContent.length - tokenContent.trimLeft().length;
+        final trailingWhitespaceCount =
+            tokenContent.length - tokenContent.trimRight().length;
+
+        startOffset += leadingWhitespaceCount;
+        endOffset -= trailingWhitespaceCount;
+        length = endOffset - startOffset;
+      }
+
+      yield HighlightRegion(region.type, lineOffset + startOffset, length);
+    }
+  }
+
+  Iterable<HighlightRegion> _splitOverlappingTokens(
+      Iterable<HighlightRegion> regions) sync* {
+    if (regions.isEmpty) {
+      return;
+    }
+
+    final sortedRegions = regions.toList()
+      ..sort((r1, r2) => r1.offset.compareTo(r2.offset));
+
+    final firstRegion = sortedRegions.first;
+    final stack = ListQueue<HighlightRegion>()..add(firstRegion);
+    var pos = firstRegion.offset;
+
+    for (final current in sortedRegions.skip(1)) {
+      if (stack.last != null) {
+        final last = stack.last;
+        final newPos = current.offset;
+        if (newPos - pos > 0) {
+          // The previous region ends at either its original end or
+          // the position of this next region, whichever is shorter.
+          final end = math.min(last.offset + last.length, newPos);
+          final length = end - pos;
+          yield HighlightRegion(last.type, pos, length);
+          pos = newPos;
+        }
+      }
+
+      stack.addLast(current);
+    }
+
+    // Process any remaining stack after the last region.
+    while (stack.isNotEmpty) {
+      final last = stack.removeLast();
+      final newPos = last.offset + last.length;
+      final length = newPos - pos;
+      if (length > 0) {
+        yield HighlightRegion(last.type, pos, length);
+        pos = newPos;
+      }
+    }
+  }
+}
+
+class SemanticTokenInfo {
+  final int line;
+  final int column;
+  final int length;
+  final SemanticTokenTypes type;
+  final Set<SemanticTokenModifiers> modifiers;
+
+  SemanticTokenInfo(
+      this.line, this.column, this.length, this.type, this.modifiers);
+
+  static int offsetSort(t1, t2) => t1.line == t2.line
+      ? t1.column.compareTo(t2.column)
+      : t1.line.compareTo(t2.line);
+}
diff --git a/pkg/analysis_server/lib/src/lsp/semantic_tokens/legend.dart b/pkg/analysis_server/lib/src/lsp/semantic_tokens/legend.dart
new file mode 100644
index 0000000..ad4220e
--- /dev/null
+++ b/pkg/analysis_server/lib/src/lsp/semantic_tokens/legend.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.
+
+import 'dart:math' as math;
+
+import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/mapping.dart';
+import 'package:meta/meta.dart';
+
+final semanticTokenLegend = SemanticTokenLegendLookup();
+
+/// A helper for looking up indexes and bitmasks of [SemanticTokenTypes] and
+/// [SemanticTokenModifiers].
+class SemanticTokenLegendLookup {
+  /// An LSP [SemanticTokensLegend] describing all supported tokens and modifiers.
+  SemanticTokensLegend lspLegend;
+
+  /// All [SemanticTokenModifiers] the server may generate. The order of these
+  /// items is important as the indexes will be used in communication between
+  /// server and client.
+  List<SemanticTokenModifiers> _usedTokenModifiers;
+
+  /// All [SemanticTokenTypes] the server may generate. The order of these
+  /// items is important as the indexes will be used in communication betewen
+  /// server and client.
+  List<SemanticTokenTypes> _usedTokenTypes;
+
+  SemanticTokenLegendLookup() {
+    // Build lists of all tokens and modifiers that exist in our mappings. These will
+    // be used to determine the indexes used for communication.
+    _usedTokenTypes = Set.of(highlightRegionTokenTypes.values).toList();
+    _usedTokenModifiers =
+        Set.of(highlightRegionTokenModifiers.values.expand((v) => v)).toList();
+
+    // Build the LSP Legend which tells the client all of the tokens and modifiers
+    // we will use in the order they should be accessed by index/bit.
+    lspLegend = SemanticTokensLegend(
+      tokenTypes:
+          _usedTokenTypes.map((tokenType) => tokenType.toString()).toList(),
+      tokenModifiers: _usedTokenModifiers
+          .map((tokenModifier) => tokenModifier.toString())
+          .toList(),
+    );
+  }
+
+  int bitmaskForModifiers(Set<SemanticTokenModifiers> modifiers) {
+    // Modifiers use a bit mask where each bit represents the index of a modifier.
+    // 001001 would indicate the 1st and 4th modifiers are applied.
+    return modifiers
+            ?.map(_usedTokenModifiers.indexOf)
+            ?.map((index) => math.pow(2, index))
+            ?.reduce((a, b) => a + b) ??
+        0;
+  }
+
+  int indexForType(SemanticTokenTypes type) {
+    return _usedTokenTypes.indexOf(type);
+  }
+
+  /// Gets the [SemanticTokenModifiers] for a given index.
+  @visibleForTesting
+  List<SemanticTokenModifiers> modifiersForBitmask(int mask) {
+    final modifiers = <SemanticTokenModifiers>[];
+    for (var i = 0; i < _usedTokenModifiers.length; i++) {
+      // Check if the i'th bit is set
+      final modifierBit = 1 << i;
+      if (mask & modifierBit != 0) {
+        modifiers.add(_usedTokenModifiers[i]);
+      }
+    }
+    return modifiers;
+  }
+
+  /// Gets the [SemanticTokenTypes] for a given index.
+  @visibleForTesting
+  SemanticTokenTypes typeForIndex(int index) => _usedTokenTypes[index];
+}
diff --git a/pkg/analysis_server/lib/src/lsp/semantic_tokens/mapping.dart b/pkg/analysis_server/lib/src/lsp/semantic_tokens/mapping.dart
new file mode 100644
index 0000000..a08df3c
--- /dev/null
+++ b/pkg/analysis_server/lib/src/lsp/semantic_tokens/mapping.dart
@@ -0,0 +1,173 @@
+// 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 'package:analysis_server/lsp_protocol/protocol_generated.dart';
+import 'package:analysis_server/src/lsp/constants.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/legend.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+
+final highlightRegionMapper = RegionTypeMapper();
+
+/// A mapping from [HighlightRegionType] to a set of [SemanticTokenModifiers].
+final highlightRegionTokenModifiers =
+    <HighlightRegionType, Set<SemanticTokenModifiers>>{
+  HighlightRegionType.COMMENT_DOCUMENTATION: {
+    SemanticTokenModifiers.documentation
+  },
+  HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.INSTANCE_FIELD_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.INSTANCE_GETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.INSTANCE_METHOD_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.INSTANCE_SETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.LOCAL_FUNCTION_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.LOCAL_VARIABLE_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.PARAMETER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.STATIC_FIELD_DECLARATION: {
+    SemanticTokenModifiers.declaration,
+    SemanticTokenModifiers.static,
+  },
+  HighlightRegionType.STATIC_GETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration,
+    SemanticTokenModifiers.static,
+  },
+  HighlightRegionType.STATIC_GETTER_REFERENCE: {SemanticTokenModifiers.static},
+  HighlightRegionType.STATIC_METHOD_DECLARATION: {
+    SemanticTokenModifiers.declaration,
+    SemanticTokenModifiers.static,
+  },
+  HighlightRegionType.STATIC_METHOD_REFERENCE: {SemanticTokenModifiers.static},
+  HighlightRegionType.STATIC_SETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration,
+    SemanticTokenModifiers.static,
+  },
+  HighlightRegionType.STATIC_SETTER_REFERENCE: {SemanticTokenModifiers.static},
+  HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION: {
+    SemanticTokenModifiers.declaration,
+    SemanticTokenModifiers.static,
+  },
+  HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+  HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION: {
+    SemanticTokenModifiers.declaration
+  },
+};
+
+/// A mapping from [HighlightRegionType] to [SemanticTokenTypes].
+final highlightRegionTokenTypes = {
+  HighlightRegionType.ANNOTATION: CustomSemanticTokenTypes.annotation,
+  HighlightRegionType.BUILT_IN: SemanticTokenTypes.keyword,
+  HighlightRegionType.CLASS: SemanticTokenTypes.class_,
+  HighlightRegionType.COMMENT_BLOCK: SemanticTokenTypes.comment,
+  HighlightRegionType.COMMENT_DOCUMENTATION: SemanticTokenTypes.comment,
+  HighlightRegionType.COMMENT_END_OF_LINE: SemanticTokenTypes.comment,
+  HighlightRegionType.CONSTRUCTOR: SemanticTokenTypes.class_,
+  HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION:
+      SemanticTokenTypes.variable,
+  HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE:
+      SemanticTokenTypes.variable,
+  HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION:
+      SemanticTokenTypes.parameter,
+  HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE: SemanticTokenTypes.parameter,
+  HighlightRegionType.ENUM: SemanticTokenTypes.enum_,
+  HighlightRegionType.ENUM_CONSTANT: SemanticTokenTypes.enumMember,
+  HighlightRegionType.FUNCTION_TYPE_ALIAS: SemanticTokenTypes.type,
+  HighlightRegionType.INSTANCE_FIELD_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.INSTANCE_FIELD_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.INSTANCE_GETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.INSTANCE_GETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.INSTANCE_METHOD_DECLARATION: SemanticTokenTypes.method,
+  HighlightRegionType.INSTANCE_METHOD_REFERENCE: SemanticTokenTypes.method,
+  HighlightRegionType.INSTANCE_SETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.INSTANCE_SETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.KEYWORD: SemanticTokenTypes.keyword,
+  HighlightRegionType.LIBRARY_NAME: SemanticTokenTypes.namespace,
+  HighlightRegionType.LITERAL_BOOLEAN: CustomSemanticTokenTypes.boolean,
+  HighlightRegionType.LITERAL_DOUBLE: SemanticTokenTypes.number,
+  HighlightRegionType.LITERAL_INTEGER: SemanticTokenTypes.number,
+  HighlightRegionType.LITERAL_STRING: SemanticTokenTypes.string,
+  HighlightRegionType.LOCAL_FUNCTION_DECLARATION: SemanticTokenTypes.function,
+  HighlightRegionType.LOCAL_FUNCTION_REFERENCE: SemanticTokenTypes.function,
+  HighlightRegionType.LOCAL_VARIABLE_DECLARATION: SemanticTokenTypes.variable,
+  HighlightRegionType.LOCAL_VARIABLE_REFERENCE: SemanticTokenTypes.variable,
+  HighlightRegionType.PARAMETER_DECLARATION: SemanticTokenTypes.parameter,
+  HighlightRegionType.PARAMETER_REFERENCE: SemanticTokenTypes.parameter,
+  HighlightRegionType.STATIC_FIELD_DECLARATION: SemanticTokenTypes.variable,
+  HighlightRegionType.STATIC_GETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.STATIC_GETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.STATIC_METHOD_DECLARATION: SemanticTokenTypes.method,
+  HighlightRegionType.STATIC_METHOD_REFERENCE: SemanticTokenTypes.method,
+  HighlightRegionType.STATIC_SETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.STATIC_SETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION:
+      SemanticTokenTypes.function,
+  HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE: SemanticTokenTypes.function,
+  HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION: SemanticTokenTypes.property,
+  HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE: SemanticTokenTypes.property,
+  HighlightRegionType.TOP_LEVEL_VARIABLE: SemanticTokenTypes.variable,
+  HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION:
+      SemanticTokenTypes.variable,
+  HighlightRegionType.TYPE_NAME_DYNAMIC: SemanticTokenTypes.type,
+  HighlightRegionType.TYPE_PARAMETER: SemanticTokenTypes.typeParameter,
+  HighlightRegionType.UNRESOLVED_INSTANCE_MEMBER_REFERENCE:
+      SemanticTokenTypes.variable,
+};
+
+/// A helper for converting from Server highlight regions to LSP semantic tokens.
+class RegionTypeMapper {
+  /// A map to get the [SemanticTokenTypes] index directly from a [HighlightRegionType].
+  final Map<HighlightRegionType, int> _tokenTypeIndexForHighlightRegion = {};
+
+  /// A map to get the [SemanticTokenModifiers] bitmask directly from a [HighlightRegionType].
+  final Map<HighlightRegionType, int> _tokenModifierBitmaskForHighlightRegion =
+      {};
+
+  RegionTypeMapper() {
+    // Build mappings that go directly from [HighlightRegionType] to index/bitmask
+    // for faster lookups.
+    for (final regionType in highlightRegionTokenTypes.keys) {
+      _tokenTypeIndexForHighlightRegion[regionType] = semanticTokenLegend
+          .indexForType(highlightRegionTokenTypes[regionType]);
+    }
+
+    for (final regionType in highlightRegionTokenTypes.keys) {
+      _tokenModifierBitmaskForHighlightRegion[regionType] = semanticTokenLegend
+          .bitmaskForModifiers(highlightRegionTokenModifiers[regionType]);
+    }
+  }
+
+  /// Gets the [SemanticTokenModifiers] bitmask for a [HighlightRegionType]. Returns
+  /// null if the region type has not been mapped.
+  int bitmaskForModifier(HighlightRegionType type) =>
+      _tokenModifierBitmaskForHighlightRegion[type];
+
+  /// Gets the [SemanticTokenTypes] index for a [HighlightRegionType]. Returns
+  /// null if the region type has not been mapped.
+  int indexForToken(HighlightRegionType type) =>
+      _tokenTypeIndexForHighlightRegion[type];
+}
diff --git a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
index 182395f..658d9b1 100644
--- a/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
+++ b/pkg/analysis_server/lib/src/lsp/server_capabilities_computer.dart
@@ -6,6 +6,7 @@
 import 'package:analysis_server/lsp_protocol/protocol_special.dart';
 import 'package:analysis_server/src/lsp/constants.dart';
 import 'package:analysis_server/src/lsp/lsp_analysis_server.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/legend.dart';
 
 /// Helper for reading client dynamic registrations which may be ommitted by the
 /// client.
@@ -38,6 +39,9 @@
     // workspace.fileOperations covers all file operation methods but we only
     // support this one.
     Method.workspace_willRenameFiles,
+    // Sematic tokens are all registered under a single "method" as the
+    // actual methods are controlled by the server capabilities.
+    CustomMethods.semanticTokenDynamicRegistration,
   ];
   final ClientCapabilities _capabilities;
 
@@ -87,6 +91,9 @@
   bool get rename =>
       _capabilities.textDocument?.rename?.dynamicRegistration ?? false;
 
+  bool get semanticTokens =>
+      _capabilities.textDocument?.semanticTokens?.dynamicRegistration ?? false;
+
   bool get signatureHelp =>
       _capabilities.textDocument?.signatureHelp?.dynamicRegistration ?? false;
 
@@ -226,6 +233,17 @@
               FoldingRangeRegistrationOptions>.t1(
               true,
             ),
+      semanticTokensProvider: dynamicRegistrations.semanticTokens
+          ? null
+          : Either2<SemanticTokensOptions,
+              SemanticTokensRegistrationOptions>.t1(
+              SemanticTokensOptions(
+                legend: semanticTokenLegend.lspLegend,
+                full: Either2<bool, SemanticTokensOptionsFull>.t2(
+                  SemanticTokensOptionsFull(delta: false),
+                ),
+              ),
+            ),
       executeCommandProvider: ExecuteCommandOptions(
         commands: Commands.serverSupportedCommands,
         workDoneProgress: true,
@@ -427,6 +445,17 @@
       dynamicRegistrations.didChangeConfiguration,
       Method.workspace_didChangeConfiguration,
     );
+    register(
+      dynamicRegistrations.semanticTokens,
+      CustomMethods.semanticTokenDynamicRegistration,
+      SemanticTokensRegistrationOptions(
+        documentSelector: fullySupportedTypes,
+        legend: semanticTokenLegend.lspLegend,
+        full: Either2<bool, SemanticTokensOptionsFull>.t2(
+          SemanticTokensOptionsFull(delta: false),
+        ),
+      ),
+    );
 
     await _applyRegistrations(registrations);
   }
diff --git a/pkg/analysis_server/lib/src/protocol_server.dart b/pkg/analysis_server/lib/src/protocol_server.dart
index ba01e37..0ad8a15 100644
--- a/pkg/analysis_server/lib/src/protocol_server.dart
+++ b/pkg/analysis_server/lib/src/protocol_server.dart
@@ -57,9 +57,14 @@
     return type != null
         ? type.getDisplayString(withNullability: false)
         : 'dynamic';
-  } else if (element is engine.FunctionTypeAliasElement) {
-    var returnType = element.function.returnType;
-    return returnType.getDisplayString(withNullability: false);
+  } else if (element is engine.TypeAliasElement) {
+    var aliasedElement = element.aliasedElement;
+    if (aliasedElement is engine.GenericFunctionTypeElement) {
+      var returnType = aliasedElement.returnType;
+      return returnType.getDisplayString(withNullability: false);
+    } else {
+      return null;
+    }
   } else {
     return null;
   }
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/utilities.dart b/pkg/analysis_server/lib/src/services/completion/dart/utilities.dart
index 41f9906..3a3c9ae 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/utilities.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/utilities.dart
@@ -250,8 +250,13 @@
       return null;
     }
     type = element.returnType;
-  } else if (element is FunctionTypeAliasElement) {
-    type = element.function.returnType;
+  } else if (element is TypeAliasElement) {
+    var aliasedElement = element.aliasedElement;
+    if (aliasedElement is GenericFunctionTypeElement) {
+      type = aliasedElement.returnType;
+    } else {
+      return null;
+    }
   } else if (element is VariableElement) {
     type = element.type;
   } else {
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart b/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart
index f4edf9b..31c1975 100644
--- a/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/producer.dart
@@ -59,11 +59,10 @@
   @override
   Iterable<CompletionSuggestion> suggestions(
       YamlCompletionRequest request) sync* {
-    // This currently assumes that all paths will be posix paths, but we might
-    // want to support platform-specific paths at some point, in which case we
-    // should add a flag to the constructor and use that to choose between the
-    // hard-coded `path.posix` and `provider.pathContext`;
-    var provider = request.resourceProvider;
+    //
+    // This currently assumes that all of the paths in the assets section will
+    // be posix paths.
+    //
     var context = path.posix;
     var separator = context.separator;
     var precedingText = request.precedingText;
@@ -80,6 +79,16 @@
       parentDirectory = parentDirectory.substring(
           0, parentDirectory.length - separator.length);
     }
+    //
+    // Convert from posix to the platform context.
+    //
+    var provider = request.resourceProvider;
+    context = provider.pathContext;
+    parentDirectory = context.joinAll(path.posix.split(parentDirectory));
+    //
+    // Resolve the relative path and access the disk to see what child entities
+    // exist within the [parentDirectory] that can be suggested.
+    //
     if (context.isRelative(parentDirectory)) {
       parentDirectory =
           context.join(context.dirname(request.filePath), parentDirectory);
diff --git a/pkg/analysis_server/test/lsp/initialization_test.dart b/pkg/analysis_server/test/lsp/initialization_test.dart
index bff75d6..ce2263f 100644
--- a/pkg/analysis_server/test/lsp/initialization_test.dart
+++ b/pkg/analysis_server/test/lsp/initialization_test.dart
@@ -131,6 +131,7 @@
     expect(initResult.capabilities.foldingRangeProvider, isNotNull);
     expect(initResult.capabilities.workspace.fileOperations.willRename,
         equals(ServerCapabilitiesComputer.fileOperationRegistrationOptions));
+    expect(initResult.capabilities.semanticTokensProvider, isNotNull);
 
     expect(didGetRegisterCapabilityRequest, isFalse);
   }
@@ -186,6 +187,7 @@
     expect(initResult.capabilities.renameProvider, isNull);
     expect(initResult.capabilities.foldingRangeProvider, isNull);
     expect(initResult.capabilities.workspace.fileOperations, isNull);
+    expect(initResult.capabilities.semanticTokensProvider, isNull);
 
     // Ensure all expected dynamic registrations.
     for (final expectedRegistration in ClientDynamicRegistrations.supported) {
diff --git a/pkg/analysis_server/test/lsp/semantic_tokens_test.dart b/pkg/analysis_server/test/lsp/semantic_tokens_test.dart
new file mode 100644
index 0000000..50b5a3f
--- /dev/null
+++ b/pkg/analysis_server/test/lsp/semantic_tokens_test.dart
@@ -0,0 +1,585 @@
+// 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 'package:analysis_server/lsp_protocol/protocol_generated.dart';
+import 'package:analysis_server/src/lsp/constants.dart';
+import 'package:analysis_server/src/lsp/semantic_tokens/legend.dart';
+import 'package:analysis_server/src/protocol/protocol_internal.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
+import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'server_abstract.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SemanticTokensTest);
+  });
+}
+
+@reflectiveTest
+class SemanticTokensTest extends AbstractLspAnalysisServerTest {
+  /// Decode tokens according to the LSP spec and pair with relevant file contents.
+  List<_Token> decodeSemanticTokens(String content, SemanticTokens tokens) {
+    final contentLines = content.split('\n').map((line) => '$line\n').toList();
+    final results = <_Token>[];
+
+    var lastLine = 0;
+    var lastColumn = 0;
+    for (var i = 0; i < tokens.data.length; i += 5) {
+      final lineDelta = tokens.data[i];
+      final columnDelta = tokens.data[i + 1];
+      final length = tokens.data[i + 2];
+      final tokenTypeIndex = tokens.data[i + 3];
+      final modifierBitmask = tokens.data[i + 4];
+
+      // Calculate the actual line/col from the deltas.
+      final line = lastLine + lineDelta;
+      final column = lineDelta == 0 ? lastColumn + columnDelta : columnDelta;
+
+      final tokenContent =
+          contentLines[line].substring(column, column + length);
+      results.add(_Token(
+        tokenContent,
+        semanticTokenLegend.typeForIndex(tokenTypeIndex),
+        semanticTokenLegend.modifiersForBitmask(modifierBitmask),
+      ));
+
+      lastLine = line;
+      lastColumn = column;
+    }
+
+    return results;
+  }
+
+  Future<void> test_class() async {
+    final content = '''
+    /// class docs
+    class MyClass<T> {
+      // class comment
+    }
+
+    // Trailing comment
+    ''';
+
+    final expected = [
+      _Token('/// class docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('T', SemanticTokenTypes.typeParameter),
+      _Token('// class comment', SemanticTokenTypes.comment),
+      _Token('// Trailing comment', SemanticTokenTypes.comment),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_class_fields() async {
+    final content = '''
+    class MyClass {
+      /// field docs
+      String myField = 'FieldVal';
+      /// static field docs
+      static String myStaticField = 'StaticFieldVal';
+    }
+
+    main() {
+      final a = MyClass();
+      print(a.myField);
+      MyClass.myStaticField = 'a';
+    }
+    ''';
+
+    final expected = [
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('/// field docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('myField', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration]),
+      _Token("'FieldVal'", SemanticTokenTypes.string),
+      _Token('/// static field docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('static', SemanticTokenTypes.keyword),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('myStaticField', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token("'StaticFieldVal'", SemanticTokenTypes.string),
+      _Token('main', SemanticTokenTypes.function,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('final', SemanticTokenTypes.keyword),
+      _Token('a', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('print', SemanticTokenTypes.function),
+      _Token('a', SemanticTokenTypes.variable),
+      _Token('myField', SemanticTokenTypes.property),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('myStaticField', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.static]),
+      _Token("'a'", SemanticTokenTypes.string),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_class_getterSetter() async {
+    final content = '''
+    class MyClass {
+      /// getter docs
+      String get myGetter => 'GetterVal';
+      /// setter docs
+      set mySetter(String v) {};
+      /// static getter docs
+      static String get myStaticGetter => 'StaticGetterVal';
+      /// static setter docs
+      static set myStaticSetter(String staticV) {};
+    }
+
+    main() {
+      final a = MyClass();
+      print(a.myGetter);
+      a.mySetter = 'a';
+    }
+    ''';
+
+    final expected = [
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('/// getter docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('get', SemanticTokenTypes.keyword),
+      _Token('myGetter', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration]),
+      _Token("'GetterVal'", SemanticTokenTypes.string),
+      _Token('/// setter docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('set', SemanticTokenTypes.keyword),
+      _Token('mySetter', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('v', SemanticTokenTypes.parameter,
+          [SemanticTokenModifiers.declaration]),
+      _Token('/// static getter docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('static', SemanticTokenTypes.keyword),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('get', SemanticTokenTypes.keyword),
+      _Token('myStaticGetter', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token("'StaticGetterVal'", SemanticTokenTypes.string),
+      _Token('/// static setter docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('static', SemanticTokenTypes.keyword),
+      _Token('set', SemanticTokenTypes.keyword),
+      _Token('myStaticSetter', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('staticV', SemanticTokenTypes.parameter,
+          [SemanticTokenModifiers.declaration]),
+      _Token('main', SemanticTokenTypes.function,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('final', SemanticTokenTypes.keyword),
+      _Token('a', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('print', SemanticTokenTypes.function),
+      _Token('a', SemanticTokenTypes.variable),
+      _Token('myGetter', SemanticTokenTypes.property),
+      _Token('a', SemanticTokenTypes.variable),
+      _Token('mySetter', SemanticTokenTypes.property),
+      _Token("'a'", SemanticTokenTypes.string),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_class_method() async {
+    final content = '''
+    class MyClass {
+      /// method docs
+      @override
+      void myMethod() {}
+      /// static method docs
+      static void myStaticMethod() {
+        // static method comment
+      }
+    }
+
+    main() {
+      final a = MyClass();
+      a.myMethod();
+      MyClass.myStaticMethod();
+    }
+    ''';
+
+    final expected = [
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('/// method docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('@', CustomSemanticTokenTypes.annotation),
+      _Token('override', SemanticTokenTypes.property),
+      _Token('void', SemanticTokenTypes.keyword),
+      _Token('myMethod', SemanticTokenTypes.method,
+          [SemanticTokenModifiers.declaration]),
+      _Token('/// static method docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('static', SemanticTokenTypes.keyword),
+      _Token('void', SemanticTokenTypes.keyword),
+      _Token('myStaticMethod', SemanticTokenTypes.method,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('// static method comment', SemanticTokenTypes.comment),
+      _Token('main', SemanticTokenTypes.function,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('final', SemanticTokenTypes.keyword),
+      _Token('a', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('a', SemanticTokenTypes.variable),
+      _Token('myMethod', SemanticTokenTypes.method),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('myStaticMethod', SemanticTokenTypes.method,
+          [SemanticTokenModifiers.static]),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_directives() async {
+    final content = '''
+    import 'package:flutter/material.dart';
+    export 'package:flutter/widgets.dart';
+    import '../file.dart';
+
+    library foo;
+    ''';
+
+    final expected = [
+      _Token('import', SemanticTokenTypes.keyword),
+      _Token("'package:flutter/material.dart'", SemanticTokenTypes.string),
+      _Token('export', SemanticTokenTypes.keyword),
+      _Token("'package:flutter/widgets.dart'", SemanticTokenTypes.string),
+      _Token('import', SemanticTokenTypes.keyword),
+      _Token("'../file.dart'", SemanticTokenTypes.string),
+      _Token('library', SemanticTokenTypes.keyword),
+      _Token('foo', SemanticTokenTypes.namespace),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_fromPlugin() async {
+    final pluginAnalyzedFilePath = join(projectFolderPath, 'lib', 'foo.foo');
+    final pluginAnalyzedFileUri = Uri.file(pluginAnalyzedFilePath);
+    final content = 'CLASS STRING VARIABLE';
+
+    final expected = [
+      _Token('CLASS', SemanticTokenTypes.class_),
+      _Token('STRING', SemanticTokenTypes.string),
+      _Token('VARIABLE', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+    ];
+
+    await initialize();
+    await openFile(pluginAnalyzedFileUri, withoutMarkers(content));
+
+    final pluginResult = plugin.AnalysisHighlightsParams(
+      pluginAnalyzedFilePath,
+      [
+        plugin.HighlightRegion(plugin.HighlightRegionType.CLASS, 0, 5),
+        plugin.HighlightRegion(plugin.HighlightRegionType.LITERAL_STRING, 6, 6),
+        plugin.HighlightRegion(
+            plugin.HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 13, 8),
+      ],
+    );
+    configureTestPlugin(notification: pluginResult.toNotification());
+
+    final tokens = await getSemanticTokens(pluginAnalyzedFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_invalidSyntax() async {
+    final content = '''
+    /// class docs
+    class MyClass {
+      // class comment
+    }
+
+    this is not valid code.
+
+    /// class docs 2
+    class MyClass2 {
+      // class comment 2
+    }
+    ''';
+
+    // Expect toe correct tokens for the valid code before/after but don't
+    // check the the tokens for the invalid code as thre are no concrete
+    // expectations for them.
+    final expected1 = [
+      _Token('/// class docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+      _Token('// class comment', SemanticTokenTypes.comment),
+    ];
+    final expected2 = [
+      _Token('/// class docs 2', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass2', SemanticTokenTypes.class_),
+      _Token('// class comment 2', SemanticTokenTypes.comment),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+
+    // Remove the tokens between the two expected sets.
+    decoded.removeRange(expected1.length, decoded.length - expected2.length);
+
+    expect(decoded, equals([...expected1, ...expected2]));
+  }
+
+  Future<void> test_lastLine_code() async {
+    final content = 'String var;';
+
+    final expected = [
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('var', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_lastLine_comment() async {
+    final content = '// Trailing comment';
+
+    final expected = [
+      _Token('// Trailing comment', SemanticTokenTypes.comment),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_lastLine_multilineComment() async {
+    final content = '''/**
+ * Trailing comment
+ */''';
+
+    final expected = [
+      _Token('/**', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('* Trailing comment', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('*/', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_multilineRegions() async {
+    final content = '''
+    /**
+     * This is my class comment
+     *
+     * There are
+     * multiple lines
+     */
+    class MyClass {}
+    ''';
+
+    final expected = [
+      _Token('/**', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('* This is my class comment', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('*', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('* There are', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('* multiple lines', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('*/', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('class', SemanticTokenTypes.keyword),
+      _Token('MyClass', SemanticTokenTypes.class_),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_strings() async {
+    final content = r'''
+    String foo(String c) => c;
+    const string1 = 'test';
+    const string2 = 'test1 $string1 test2 ${foo('test3')}';
+    const string3 = r'$string1 ${string1.length}';
+    ''';
+
+    final expected = [
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('foo', SemanticTokenTypes.function,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('c', SemanticTokenTypes.parameter,
+          [SemanticTokenModifiers.declaration]),
+      _Token('c', SemanticTokenTypes.parameter),
+      _Token('const', SemanticTokenTypes.keyword),
+      _Token('string1', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token("'test'", SemanticTokenTypes.string),
+      _Token('const', SemanticTokenTypes.keyword),
+      _Token('string2', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token(r"'test1 ", SemanticTokenTypes.string),
+      _Token('string1', SemanticTokenTypes.property),
+      _Token(' test2 ', SemanticTokenTypes.string),
+      _Token('foo', SemanticTokenTypes.function),
+      _Token("'test3'", SemanticTokenTypes.string),
+      _Token("'", SemanticTokenTypes.string),
+      _Token('const', SemanticTokenTypes.keyword),
+      // string3 is raw and should be treated as a single string.
+      _Token('string3', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token(r"r'$string1 ${string1.length}'", SemanticTokenTypes.string),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+
+  Future<void> test_topLevel() async {
+    final content = '''
+    /// strings docs
+    const strings = <String>["test", 'test', r'test', \'''test\'''];
+
+    /// func docs
+    func(String a) => print(a);
+
+    /// abc docs
+    bool get abc => true;
+    ''';
+
+    final expected = [
+      _Token('/// strings docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('const', SemanticTokenTypes.keyword),
+      _Token('strings', SemanticTokenTypes.variable,
+          [SemanticTokenModifiers.declaration]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('"test"', SemanticTokenTypes.string),
+      _Token("'test'", SemanticTokenTypes.string),
+      _Token("r'test'", SemanticTokenTypes.string),
+      _Token("'''test'''", SemanticTokenTypes.string),
+      _Token('/// func docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('func', SemanticTokenTypes.function,
+          [SemanticTokenModifiers.declaration, SemanticTokenModifiers.static]),
+      _Token('String', SemanticTokenTypes.class_),
+      _Token('a', SemanticTokenTypes.parameter,
+          [SemanticTokenModifiers.declaration]),
+      _Token('print', SemanticTokenTypes.function),
+      _Token('a', SemanticTokenTypes.parameter),
+      _Token('/// abc docs', SemanticTokenTypes.comment,
+          [SemanticTokenModifiers.documentation]),
+      _Token('bool', SemanticTokenTypes.class_),
+      _Token('get', SemanticTokenTypes.keyword),
+      _Token('abc', SemanticTokenTypes.property,
+          [SemanticTokenModifiers.declaration]),
+      _Token('true', CustomSemanticTokenTypes.boolean),
+    ];
+
+    await initialize();
+    await openFile(mainFileUri, withoutMarkers(content));
+
+    final tokens = await getSemanticTokens(mainFileUri);
+    final decoded = decodeSemanticTokens(content, tokens);
+    expect(decoded, equals(expected));
+  }
+}
+
+class _Token {
+  final String content;
+  final SemanticTokenTypes type;
+  final List<SemanticTokenModifiers> modifiers;
+
+  _Token(this.content, this.type, [this.modifiers = const []]);
+
+  @override
+  int get hashCode => content.hashCode;
+
+  @override
+  bool operator ==(Object o) =>
+      o is _Token &&
+      o.content == content &&
+      o.type == type &&
+      listEqual(
+          // Treat nulls the same as empty lists for convenience when comparing.
+          o.modifiers ?? <SemanticTokenModifiers>[],
+          modifiers ?? <SemanticTokenModifiers>[],
+          (SemanticTokenModifiers a, SemanticTokenModifiers b) => a == b);
+
+  @override
+  String toString() => '$content (${[type, ...?modifiers]})';
+}
diff --git a/pkg/analysis_server/test/lsp/server_abstract.dart b/pkg/analysis_server/test/lsp/server_abstract.dart
index a832811..6388898 100644
--- a/pkg/analysis_server/test/lsp/server_abstract.dart
+++ b/pkg/analysis_server/test/lsp/server_abstract.dart
@@ -222,6 +222,12 @@
       'codeAction': {'dynamicRegistration': true},
       'rename': {'dynamicRegistration': true},
       'foldingRange': {'dynamicRegistration': true},
+      'semanticTokens': SemanticTokensClientCapabilities(
+          dynamicRegistration: true,
+          requests: SemanticTokensClientCapabilitiesRequests(),
+          formats: [],
+          tokenModifiers: [],
+          tokenTypes: []).toJson(),
     });
   }
 
@@ -1014,6 +1020,16 @@
         request, _fromJsonList(Location.fromJson));
   }
 
+  Future<SemanticTokens> getSemanticTokens(Uri uri) {
+    final request = makeRequest(
+      Method.textDocument_semanticTokens_full,
+      SemanticTokensParams(
+        textDocument: TextDocumentIdentifier(uri: uri.toString()),
+      ),
+    );
+    return expectSuccessfulResponseTo(request, SemanticTokens.fromJson);
+  }
+
   Future<SignatureHelp> getSignatureHelp(Uri uri, Position pos,
       [SignatureHelpContext context]) {
     final request = makeRequest(
diff --git a/pkg/analysis_server/test/lsp/test_all.dart b/pkg/analysis_server/test/lsp/test_all.dart
index 0756d4e..aa30754 100644
--- a/pkg/analysis_server/test/lsp/test_all.dart
+++ b/pkg/analysis_server/test/lsp/test_all.dart
@@ -34,6 +34,7 @@
 import 'reanalyze_test.dart' as reanalyze;
 import 'references_test.dart' as references;
 import 'rename_test.dart' as rename;
+import 'semantic_tokens_test.dart' as semantic_tokens;
 import 'server_test.dart' as server;
 import 'signature_help_test.dart' as signature_help;
 import 'super_test.dart' as get_super;
@@ -73,6 +74,7 @@
     reanalyze.main();
     references.main();
     rename.main();
+    semantic_tokens.main();
     server.main();
     signature_help.main();
     will_rename_files.main();
diff --git a/pkg/analysis_server/test/src/computer/highlights_computer_test.dart b/pkg/analysis_server/test/src/computer/highlights_computer_test.dart
index d251985..5880e68 100644
--- a/pkg/analysis_server/test/src/computer/highlights_computer_test.dart
+++ b/pkg/analysis_server/test/src/computer/highlights_computer_test.dart
@@ -66,6 +66,23 @@
     _check(HighlightRegionType.KEYWORD, 'null');
   }
 
+  Future<void> test_string_interpolated() async {
+    await _computeHighlights(r'''
+class A {
+  String b(String c) => c;
+}
+var foo = A();
+var bar = A();
+var s = 'test1 $foo test2 ${bar.b('test3')}';
+''');
+    _check(HighlightRegionType.LITERAL_STRING, "'test1 ");
+    _check(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'foo');
+    _check(HighlightRegionType.LITERAL_STRING, ' test2 ');
+    _check(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'bar');
+    _check(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'b');
+    _check(HighlightRegionType.LITERAL_STRING, "'test3'");
+  }
+
   Future<void> test_throwExpression() async {
     await _computeHighlights('''
 void main() {
diff --git a/pkg/analysis_server/tool/lsp_spec/README.md b/pkg/analysis_server/tool/lsp_spec/README.md
index 27649ab..11227a8 100644
--- a/pkg/analysis_server/tool/lsp_spec/README.md
+++ b/pkg/analysis_server/tool/lsp_spec/README.md
@@ -102,6 +102,7 @@
 | textDocument/rename | ✅ | ✅ | | ✅ | ✅ |
 | textDocument/prepareRename | ✅ | ✅ | | ✅ | ✅ |
 | textDocument/foldingRange | ✅ | ✅ | ✅ | ✅ | ✅ |
+| textDocument/semanticTokens/full | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ## Custom Methods and Notifications
 
diff --git a/pkg/analyzer/CHANGELOG.md b/pkg/analyzer/CHANGELOG.md
index 227a18e..665eb9b 100644
--- a/pkg/analyzer/CHANGELOG.md
+++ b/pkg/analyzer/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.41.2-dev
+* Deprecated `FunctionTypeAliasElement.function`.
+  Use `TypeAliasElement.aliasedElement` instead.
+
 ## 0.41.1
 * Updated `PackageBuildWorkspace` that supports `package:build` to stop
   at the first directory with `pubspec.yaml`, and don't try to go up
diff --git a/pkg/analyzer/lib/dart/element/element.dart b/pkg/analyzer/lib/dart/element/element.dart
index 44d3ec9..be78683 100644
--- a/pkg/analyzer/lib/dart/element/element.dart
+++ b/pkg/analyzer/lib/dart/element/element.dart
@@ -993,6 +993,8 @@
 
   R visitTopLevelVariableElement(TopLevelVariableElement element);
 
+  R visitTypeAliasElement(TypeAliasElement element);
+
   R visitTypeParameterElement(TypeParameterElement element);
 }
 
@@ -1167,6 +1169,7 @@
 abstract class FunctionTypeAliasElement implements TypeAliasElement {
   /// Return the generic function type element representing the generic function
   /// type on the right side of the equals.
+  @Deprecated('Use aliasedElement instead')
   GenericFunctionTypeElement get function;
 
   @override
diff --git a/pkg/analyzer/lib/dart/element/visitor.dart b/pkg/analyzer/lib/dart/element/visitor.dart
index 70552ed..f6256b8 100644
--- a/pkg/analyzer/lib/dart/element/visitor.dart
+++ b/pkg/analyzer/lib/dart/element/visitor.dart
@@ -176,6 +176,9 @@
       visitPropertyInducingElement(element);
 
   @override
+  R visitTypeAliasElement(TypeAliasElement element) => visitElement(element);
+
+  @override
   R visitTypeParameterElement(TypeParameterElement element) =>
       visitElement(element);
 
@@ -318,6 +321,12 @@
   }
 
   @override
+  R visitTypeAliasElement(TypeAliasElement element) {
+    element.visitChildren(this);
+    return null;
+  }
+
+  @override
   R visitTypeParameterElement(TypeParameterElement element) {
     element.visitChildren(this);
     return null;
@@ -396,6 +405,9 @@
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
   @override
+  R visitTypeAliasElement(TypeAliasElement element) => null;
+
+  @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
 
@@ -478,6 +490,9 @@
       _throw(element);
 
   @override
+  R visitTypeAliasElement(TypeAliasElement element) => _throw(element);
+
+  @override
   R visitTypeParameterElement(TypeParameterElement element) => _throw(element);
 
   R _throw(Element element) {
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index d23a5ab..db1046a 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -6964,7 +6964,7 @@
   /// from anywhere except a class element or type parameter bounds.
   bool hasSelfReference = false;
 
-  bool _isRawElementReady = false;
+  bool _isAliasedElementReady = false;
   ElementImpl _aliasedElement;
   DartType _aliasedType;
 
@@ -7107,8 +7107,7 @@
 
   @override
   T accept<T>(ElementVisitor<T> visitor) {
-    // TODO(scheglov) `visitTypeAliasElement`
-    throw UnimplementedError();
+    return visitor.visitTypeAliasElement(this);
   }
 
   @override
@@ -7151,8 +7150,8 @@
   }
 
   void _ensureAliasedElement() {
-    if (_isRawElementReady) return;
-    _isRawElementReady = true;
+    if (_isAliasedElementReady) return;
+    _isAliasedElementReady = true;
 
     var linkedNode = this.linkedNode;
     if (linkedNode != null) {
diff --git a/pkg/analyzer/lib/src/dart/element/type.dart b/pkg/analyzer/lib/src/dart/element/type.dart
index 2b9613f..18dc224 100644
--- a/pkg/analyzer/lib/src/dart/element/type.dart
+++ b/pkg/analyzer/lib/src/dart/element/type.dart
@@ -139,8 +139,11 @@
   FunctionTypedElement get element {
     var element = super.element;
     // TODO(scheglov) Can we just construct it with the right element?
-    if (element is FunctionTypeAliasElement) {
-      return element.function;
+    if (element is TypeAliasElement) {
+      var aliasedElement = element.aliasedElement;
+      if (aliasedElement is GenericFunctionTypeElement) {
+        return aliasedElement;
+      }
     }
     return element;
   }
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 321257f..ba5b449 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -2733,9 +2733,11 @@
         parent.declaredElement.parameters,
       );
     } else if (parent is FunctionTypeAlias) {
+      var aliasedElement = parent.declaredElement.aliasedElement;
+      var functionElement = aliasedElement as GenericFunctionTypeElement;
       nameScope = FormalParameterScope(
         nameScope,
-        parent.declaredElement.function.parameters,
+        functionElement.parameters,
       );
     } else if (parent is MethodDeclaration) {
       nameScope = FormalParameterScope(
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index 6add61d..7e76747 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -47,16 +47,17 @@
     throw StateError('Not found: $name');
   }
 
-  ImportElement import(String targetUri) {
+  ImportElement import(String targetUri, {bool mustBeUnique = true}) {
     ImportElement importElement;
 
     for (var import in unitElement.library.imports) {
       var importedUri = import.importedLibrary.source.uri.toString();
       if (importedUri == targetUri) {
-        if (importElement != null) {
+        if (importElement == null) {
+          importElement = import;
+        } else if (mustBeUnique) {
           throw StateError('Not unique: $targetUri');
         }
-        importElement = import;
       }
     }
 
@@ -66,8 +67,8 @@
     throw StateError('Not found: $targetUri');
   }
 
-  ImportFindElement importFind(String targetUri) {
-    var import = this.import(targetUri);
+  ImportFindElement importFind(String targetUri, {bool mustBeUnique = true}) {
+    var import = this.import(targetUri, mustBeUnique: mustBeUnique);
     return ImportFindElement(import);
   }
 
@@ -147,8 +148,11 @@
     findInExecutables(unitElement.accessors);
     findInExecutables(unitElement.functions);
 
-    for (var function in unitElement.functionTypeAliases) {
-      findIn(function.function.parameters);
+    for (var alias in unitElement.typeAliases) {
+      var aliasedElement = alias.aliasedElement;
+      if (aliasedElement is GenericFunctionTypeElement) {
+        findIn(aliasedElement.parameters);
+      }
     }
 
     for (var extension_ in unitElement.extensions) {
@@ -183,6 +187,29 @@
     throw StateError('Not found: $name');
   }
 
+  CompilationUnitElement part(String targetUri) {
+    CompilationUnitElement partElement;
+
+    for (var part in unitElement.library.parts) {
+      if (part.uri == targetUri) {
+        if (partElement != null) {
+          throw StateError('Not unique: $targetUri');
+        }
+        partElement = part;
+      }
+    }
+
+    if (partElement != null) {
+      return partElement;
+    }
+    throw StateError('Not found: $targetUri');
+  }
+
+  PartFindElement partFind(String targetUri) {
+    var part = this.part(targetUri);
+    return PartFindElement(part);
+  }
+
   PrefixElement prefix(String name) {
     for (var import_ in unitElement.library.imports) {
       var prefix = import_.prefix;
@@ -218,9 +245,13 @@
       findIn(type.typeParameters);
     }
 
-    for (var type in unitElement.functionTypeAliases) {
-      findIn(type.typeParameters);
-      findIn(type.function.typeParameters);
+    for (var alias in unitElement.typeAliases) {
+      findIn(alias.typeParameters);
+
+      var aliasedElement = alias.aliasedElement;
+      if (aliasedElement is GenericFunctionTypeElement) {
+        findIn(aliasedElement.typeParameters);
+      }
     }
 
     for (var class_ in unitElement.types) {
@@ -254,6 +285,13 @@
   }
 }
 
+class PartFindElement extends _FindElementBase {
+  @override
+  final CompilationUnitElement unitElement;
+
+  PartFindElement(this.unitElement);
+}
+
 abstract class _FindElementBase {
   CompilationUnitElement get unitElement;
 
diff --git a/pkg/analyzer/lib/src/test_utilities/find_node.dart b/pkg/analyzer/lib/src/test_utilities/find_node.dart
index 07b410e..11bd738 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_node.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_node.dart
@@ -83,6 +83,10 @@
     return _node(search, (n) => n is ConstructorFieldInitializer);
   }
 
+  ConstructorName constructorName(String search) {
+    return _node(search, (n) => n is ConstructorName);
+  }
+
   ContinueStatement continueStatement(String search) {
     return _node(search, (n) => n is ContinueStatement);
   }
@@ -211,6 +215,19 @@
     return _node(search, (n) => n is NullLiteral);
   }
 
+  /// Return the unique offset where the [search] string occurs in [content].
+  /// Throws if not found, or if not unique.
+  int offset(String search) {
+    var offset = content.indexOf(search);
+    if (content.contains(search, offset + 1)) {
+      throw StateError('The pattern |$search| is not unique in:\n$content');
+    }
+    if (offset < 0) {
+      throw StateError('The pattern |$search| is not found in:\n$content');
+    }
+    return offset;
+  }
+
   ParenthesizedExpression parenthesized(String search) {
     return _node(search, (n) => n is ParenthesizedExpression);
   }
@@ -337,15 +354,9 @@
   }
 
   AstNode _node(String search, bool Function(AstNode) predicate) {
-    var index = content.indexOf(search);
-    if (content.contains(search, index + 1)) {
-      throw StateError('The pattern |$search| is not unique in:\n$content');
-    }
-    if (index < 0) {
-      throw StateError('The pattern |$search| is not found in:\n$content');
-    }
+    int offset = this.offset(search);
 
-    var node = NodeLocator2(index).searchWithin(unit);
+    var node = NodeLocator2(offset).searchWithin(unit);
     if (node == null) {
       throw StateError(
           'The pattern |$search| had no corresponding node in:\n$content');
diff --git a/pkg/analyzer/pubspec.yaml b/pkg/analyzer/pubspec.yaml
index 197a044..b61f2fb 100644
--- a/pkg/analyzer/pubspec.yaml
+++ b/pkg/analyzer/pubspec.yaml
@@ -1,5 +1,5 @@
 name: analyzer
-version: 0.41.1
+version: 0.41.2-dev
 description: This package provides a library that performs static analysis of Dart code.
 homepage: https://github.com/dart-lang/sdk/tree/master/pkg/analyzer
 
diff --git a/pkg/analyzer/test/src/dart/analysis/base.dart b/pkg/analyzer/test/src/dart/analysis/base.dart
index 166c8b9..91a5398 100644
--- a/pkg/analyzer/test/src/dart/analysis/base.dart
+++ b/pkg/analyzer/test/src/dart/analysis/base.dart
@@ -4,8 +4,6 @@
 
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/results.dart';
-import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/packages.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
@@ -25,26 +23,6 @@
 import 'package:pub_semver/pub_semver.dart';
 import 'package:test/test.dart';
 
-/// Finds an [Element] with the given [name].
-Element findChildElement(Element root, String name, [ElementKind kind]) {
-  Element result;
-  root.accept(_ElementVisitorFunctionWrapper((Element element) {
-    if (element.name != name) {
-      return;
-    }
-    if (kind != null && element.kind != kind) {
-      return;
-    }
-    result = element;
-  }));
-  return result;
-}
-
-typedef Predicate<E> = bool Function(E argument);
-
-/// A function to be called for every [Element].
-typedef _ElementVisitorFunction = void Function(Element element);
-
 class BaseAnalysisDriverTest with ResourceProviderMixin {
   DartSdk sdk;
   final ByteStore byteStore = MemoryByteStore();
@@ -176,19 +154,6 @@
   void tearDown() {}
 }
 
-/// Wraps an [_ElementVisitorFunction] into a [GeneralizingElementVisitor].
-class _ElementVisitorFunctionWrapper extends GeneralizingElementVisitor {
-  final _ElementVisitorFunction function;
-
-  _ElementVisitorFunctionWrapper(this.function);
-
-  @override
-  visitElement(Element element) {
-    function(element);
-    super.visitElement(element);
-  }
-}
-
 class _GeneratedUriResolverMock implements UriResolver {
   Source Function(Uri, Uri) resolveAbsoluteFunction;
 
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
index 3ba26a1..b10a2b7 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
@@ -7600,22 +7600,22 @@
     CompilationUnitElement unitElement = unit.declaredElement;
 
     FunctionTypeAlias alias = unit.declarations[0];
-    FunctionTypeAliasElement aliasElement = alias.declaredElement;
-    GenericFunctionTypeElement aliasFunction = aliasElement.function;
+    TypeAliasElement aliasElement = alias.declaredElement;
+    var function = aliasElement.aliasedElement as GenericFunctionTypeElement;
     expect(aliasElement, same(unitElement.functionTypeAliases[0]));
-    expect(aliasFunction.returnType, typeProvider.intType);
+    expect(function.returnType, typeProvider.intType);
 
     _assertTypeNameSimple(alias.returnType, typeProvider.intType);
 
     _assertSimpleParameter(
-        alias.parameters.parameters[0], aliasFunction.parameters[0],
+        alias.parameters.parameters[0], function.parameters[0],
         name: 'a',
         offset: 22,
         kind: ParameterKind.REQUIRED,
         type: typeProvider.boolType);
 
     _assertSimpleParameter(
-        alias.parameters.parameters[1], aliasFunction.parameters[1],
+        alias.parameters.parameters[1], function.parameters[1],
         name: 'b',
         offset: 27,
         kind: ParameterKind.REQUIRED,
@@ -8542,11 +8542,10 @@
       SimpleIdentifier identifier = prefixed.identifier;
       assertSimpleIdentifier(
         identifier,
-        readElement: elementMatcher(
+        element: elementMatcher(
           objectHashCode,
           isLegacy: isNullSafetySdkAndLegacyLibrary,
         ),
-        writeElement: null,
         type: 'int',
       );
     }
diff --git a/pkg/analyzer/test/src/dart/analysis/index_test.dart b/pkg/analyzer/test/src/dart/analysis/index_test.dart
index b73f5bf..eacf5d6 100644
--- a/pkg/analyzer/test/src/dart/analysis/index_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/index_test.dart
@@ -4,17 +4,15 @@
 
 import 'dart:convert';
 
-import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/analysis/index.dart';
-import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
-import 'package:analyzer/src/test_utilities/find_node.dart';
+import 'package:analyzer/src/test_utilities/find_element.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-import 'base.dart';
+import '../resolution/context_collection_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
@@ -23,27 +21,20 @@
 }
 
 class ExpectedLocation {
-  final CompilationUnitElement unitElement;
   final int offset;
   final int length;
   final bool isQualified;
 
-  ExpectedLocation(
-      this.unitElement, this.offset, this.length, this.isQualified);
+  ExpectedLocation(this.offset, this.length, this.isQualified);
 
   @override
   String toString() {
-    return '(unit=$unitElement; offset=$offset; length=$length;'
-        ' isQualified=$isQualified)';
+    return '(offset=$offset; length=$length; isQualified=$isQualified)';
   }
 }
 
 @reflectiveTest
-class IndexTest extends BaseAnalysisDriverTest {
-  CompilationUnit testUnit;
-  CompilationUnitElement testUnitElement;
-  LibraryElement testLibraryElement;
-
+class IndexTest extends PubPackageResolutionTest {
   AnalysisDriverUnitIndex index;
 
   _ElementIndexAssert assertThat(Element element) {
@@ -55,13 +46,12 @@
     return _NameIndexAssert(this, name);
   }
 
-  Element findElement(String name, [ElementKind kind]) {
-    return findChildElement(testUnitElement, name, kind);
-  }
-
-  CompilationUnitElement importedUnit({int index = 0}) {
-    List<ImportElement> imports = testLibraryElement.imports;
-    return imports[index].importedLibrary.definingCompilationUnit;
+  /// Return [ImportFindElement] for 'package:test/lib.dart' import.
+  ImportFindElement importFindLib() {
+    return findElement.importFind(
+      'package:test/lib.dart',
+      mustBeUnique: false,
+    );
   }
 
   test_fieldFormalParameter_noSuchField() async {
@@ -88,7 +78,7 @@
 class C4 implements B2 {}
 class M extends Object with A {}
 ''');
-    ClassElement classElementA = findElement("A");
+    ClassElement classElementA = findElement.class_('A');
     assertThat(classElementA)
       ..isAncestorOf('B1 extends A')
       ..isAncestorOf('B2 implements A')
@@ -106,8 +96,8 @@
 class C1 = Object with A;
 class C2 = Object with B;
 ''');
-    ClassElement classElementA = findElement('A');
-    ClassElement classElementB = findElement('B');
+    ClassElement classElementA = findElement.class_('A');
+    ClassElement classElementB = findElement.class_('B');
     assertThat(classElementA)
       ..isAncestorOf('C1 = Object with A')
       ..isAncestorOf('C2 = Object with B');
@@ -125,7 +115,7 @@
 mixin M4 implements B {}
 mixin M5 on M2 {}
 ''');
-    ClassElement classElementA = findElement('A');
+    ClassElement classElementA = findElement.class_('A');
     assertThat(classElementA)
       ..isAncestorOf('B extends A')
       ..isAncestorOf('M1 on A')
@@ -136,14 +126,14 @@
   }
 
   test_isExtendedBy_ClassDeclaration_isQualified() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B extends p.A {} // 2
 ''');
-    ClassElement elementA = importedUnit().getType('A');
+    ClassElement elementA = importFindLib().class_('A');
     assertThat(elementA).isExtendedAt('A {} // 2', true);
   }
 
@@ -151,7 +141,7 @@
     await _indexTestUnit('''
 class A {}
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     ClassElement elementObject = elementA.supertype.element;
     assertThat(elementObject).isExtendedAt('A {}', true, length: 0);
   }
@@ -162,14 +152,14 @@
 class B {}
 class C = A with B;
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA)
       ..isExtendedAt('A with', false)
       ..isReferencedAt('A with', false);
   }
 
   test_isExtendedBy_ClassTypeAlias_isQualified() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 ''');
     await _indexTestUnit('''
@@ -177,7 +167,7 @@
 class B {}
 class C = p.A with B;
 ''');
-    ClassElement elementA = importedUnit().getType('A');
+    ClassElement elementA = importFindLib().class_('A');
     assertThat(elementA)
       ..isExtendedAt('A with', true)
       ..isReferencedAt('A with', true);
@@ -188,21 +178,21 @@
 class A {} // 1
 class B implements A {} // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isImplementedBy_ClassDeclaration_isQualified() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B implements p.A {} // 2
 ''');
-    ClassElement elementA = importedUnit().getType('A');
+    ClassElement elementA = importFindLib().class_('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', true)
       ..isReferencedAt('A {} // 2', true);
@@ -214,7 +204,7 @@
 class B {} // 2
 class C = Object with A implements B; // 3
 ''');
-    ClassElement elementB = findElement('B');
+    ClassElement elementB = findElement.class_('B');
     assertThat(elementB)
       ..isImplementedAt('B; // 3', false)
       ..isReferencedAt('B; // 3', false);
@@ -225,7 +215,7 @@
 class A {} // 1
 mixin M implements A {} // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
@@ -236,14 +226,14 @@
 class A {} // 1
 mixin M on A {} // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA)
       ..isImplementedAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isInvokedBy_FunctionElement() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 library lib;
 foo() {}
 ''');
@@ -254,7 +244,7 @@
   pref.foo(); // q
   foo(); // nq
 }''');
-    FunctionElement element = importedUnit().functions[0];
+    FunctionElement element = importFindLib().topFunction('foo');
     assertThat(element)
       ..isInvokedAt('foo(); // q', true)
       ..isInvokedAt('foo(); // nq', false);
@@ -268,7 +258,7 @@
   math.loadLibrary(); // 2
 }
 ''');
-    LibraryElement mathLib = testLibraryElement.imports[0].importedLibrary;
+    LibraryElement mathLib = findElement.import('dart:math').importedLibrary;
     FunctionElement element = mathLib.loadLibraryFunction;
     assertThat(element).isInvokedAt('loadLibrary(); // 1', true);
     assertThat(element).isInvokedAt('loadLibrary(); // 2', true);
@@ -283,7 +273,7 @@
     foo(); // nq
   }
 }''');
-    Element element = findElement('foo');
+    MethodElement element = findElement.method('foo');
     assertThat(element)
       ..isInvokedAt('foo(); // q', true)
       ..isInvokedAt('foo(); // nq', false);
@@ -299,7 +289,7 @@
   0.foo();
 }
 ''');
-    MethodElement element = findElement('foo');
+    MethodElement element = findElement.method('foo');
     assertThat(element)..isInvokedAt('foo();', true);
   }
 
@@ -313,7 +303,7 @@
   E.foo();
 }
 ''');
-    MethodElement element = findElement('foo');
+    MethodElement element = findElement.method('foo');
     assertThat(element)..isInvokedAt('foo();', true);
   }
 
@@ -332,7 +322,6 @@
   (1.2).foo(); // double ref
 }
 ''');
-    var findNode = FindNode(testCode, testUnit);
 
     var intMethod = findNode.methodDeclaration('foo() {} // int');
     assertThat(intMethod.declaredElement)
@@ -353,7 +342,7 @@
   a.foo();
 }
 ''');
-    Element element = findElement('foo');
+    MethodElement element = findElement.method('foo');
     assertThat(element).isInvokedAt('foo();', true);
   }
 
@@ -369,7 +358,7 @@
   a++;
 }
 ''');
-    MethodElement element = findElement('+');
+    MethodElement element = findElement.method('+');
     assertThat(element)
       ..isInvokedAt('+ 1', true, length: 1)
       ..isInvokedAt('+= 2', true, length: 2)
@@ -388,8 +377,8 @@
   a[1] = 42;
 }
 ''');
-    MethodElement readElement = findElement('[]');
-    MethodElement writeElement = findElement('[]=');
+    MethodElement readElement = findElement.method('[]');
+    MethodElement writeElement = findElement.method('[]=');
     assertThat(readElement).isInvokedAt('[0]', true, length: 1);
     assertThat(writeElement).isInvokedAt('[1]', true, length: 1);
   }
@@ -403,7 +392,7 @@
   print(~a);
 }
 ''');
-    MethodElement element = findElement('~');
+    MethodElement element = findElement.method('~');
     assertThat(element).isInvokedAt('~a', true, length: 1);
   }
 
@@ -412,21 +401,21 @@
 class A {} // 1
 class B extends Object with A {} // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA)
       ..isMixedInAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
   }
 
   test_isMixedInBy_ClassDeclaration_isQualified() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' as p;
 class B extends Object with p.A {} // 2
 ''');
-    ClassElement elementA = importedUnit().getType('A');
+    ClassElement elementA = importFindLib().class_('A');
     assertThat(elementA).isMixedInAt('A {} // 2', true);
   }
 
@@ -435,7 +424,7 @@
 mixin A {} // 1
 class B extends Object with A {} // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.mixin('A');
     assertThat(elementA)
       ..isMixedInAt('A {} // 2', false)
       ..isReferencedAt('A {} // 2', false);
@@ -446,7 +435,7 @@
 class A {} // 1
 class B = Object with A; // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.class_('A');
     assertThat(elementA).isMixedInAt('A; // 2', false);
   }
 
@@ -455,7 +444,7 @@
 mixin A {} // 1
 class B = Object with A; // 2
 ''');
-    ClassElement elementA = findElement('A');
+    ClassElement elementA = findElement.mixin('A');
     assertThat(elementA).isMixedInAt('A; // 2', false);
   }
 
@@ -468,7 +457,7 @@
     field(); // nq
   }
 }''');
-    FieldElement field = findElement('field');
+    FieldElement field = findElement.field('field');
     assertThat(field.getter)
       ..isReferencedAt('field(); // q', true)
       ..isReferencedAt('field(); // nq', false);
@@ -483,7 +472,7 @@
     ggg(); // nq
   }
 }''');
-    PropertyAccessorElement element = findElement('ggg', ElementKind.GETTER);
+    PropertyAccessorElement element = findElement.getter('ggg');
     assertThat(element)
       ..isReferencedAt('ggg(); // q', true)
       ..isReferencedAt('ggg(); // nq', false);
@@ -501,7 +490,7 @@
   print(A.field); // 3
 }
 ''');
-    ClassElement element = findElement('A');
+    ClassElement element = findElement.class_('A');
     assertThat(element)
       ..isReferencedAt('A p) {', false)
       ..isReferencedAt('A v;', false)
@@ -519,7 +508,7 @@
   MyEnum.a;
 }
 ''');
-    ClassElement element = findElement('MyEnum');
+    ClassElement element = findElement.enum_('MyEnum');
     assertThat(element)
       ..isReferencedAt('MyEnum p) {', false)
       ..isReferencedAt('MyEnum v;', false)
@@ -532,22 +521,22 @@
 
 extension E on A<int> {}
 ''');
-    ClassElement element = findElement('A');
+    ClassElement element = findElement.class_('A');
     assertThat(element)..isReferencedAt('A<int>', false);
   }
 
-  test_isReferencedBy_ClassElement_invocation() async {
+  test_isReferencedBy_ClassElement_implicitNew() async {
     await _indexTestUnit('''
 class A {}
 main() {
   A(); // invalid code, but still a reference
 }''');
-    Element element = findElement('A');
+    ClassElement element = findElement.class_('A');
     assertThat(element).isReferencedAt('A();', false);
   }
 
   test_isReferencedBy_ClassElement_invocation_isQualified() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 ''');
     await _indexTestUnit('''
@@ -555,7 +544,7 @@
 main() {
   p.A(); // invalid code, but still a reference
 }''');
-    Element element = importedUnit().getType('A');
+    Element element = importFindLib().class_('A');
     assertThat(element).isReferencedAt('A();', true);
   }
 
@@ -567,7 +556,7 @@
   f<A>();
 }
 ''');
-    Element element = findElement('A');
+    ClassElement element = findElement.class_('A');
     assertThat(element)..isReferencedAt('A>();', false);
   }
 
@@ -579,47 +568,47 @@
   B v;
 }
 ''');
-    ClassElement element = findElement('B');
+    ClassElement element = findElement.class_('B');
     assertThat(element)
       ..isReferencedAt('B p) {', false)
       ..isReferencedAt('B v;', false);
   }
 
   test_isReferencedBy_CompilationUnitElement_export() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 library lib;
 ''');
     await _indexTestUnit('''
 export 'lib.dart';
 ''');
-    LibraryElement element = testLibraryElement.exports[0].exportedLibrary;
+    var element = findElement.export('package:test/lib.dart').exportedLibrary;
     assertThat(element)..isReferencedAt("'lib.dart'", true, length: 10);
   }
 
   test_isReferencedBy_CompilationUnitElement_import() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 library lib;
 ''');
     await _indexTestUnit('''
 import 'lib.dart';
 ''');
-    LibraryElement element = testLibraryElement.imports[0].importedLibrary;
+    var element = findElement.import('package:test/lib.dart').importedLibrary;
     assertThat(element)..isReferencedAt("'lib.dart'", true, length: 10);
   }
 
   test_isReferencedBy_CompilationUnitElement_part() async {
-    newFile('$testProject2/my_unit.dart', content: 'part of my_lib;');
+    newFile('$testPackageLibPath/my_unit.dart', content: 'part of my_lib;');
     await _indexTestUnit('''
 library my_lib;
 part 'my_unit.dart';
 ''');
-    CompilationUnitElement element = testLibraryElement.parts[0];
+    var element = findElement.part('my_unit.dart');
     assertThat(element)..isReferencedAt("'my_unit.dart';", true, length: 14);
   }
 
   test_isReferencedBy_CompilationUnitElement_part_inPart() async {
-    newFile('$testProject2/a.dart', content: 'part of lib;');
-    newFile('$testProject2/b.dart', content: '''
+    newFile('$testPackageLibPath/a.dart', content: 'part of lib;');
+    newFile('$testPackageLibPath/b.dart', content: '''
 library lib;
 part 'a.dart';
 ''');
@@ -645,9 +634,8 @@
   new A.foo(); // 5
 }
 ''');
-    ClassElement classA = findElement('A');
-    ConstructorElement constA = classA.constructors[0];
-    ConstructorElement constA_foo = classA.constructors[1];
+    var constA = findElement.unnamedConstructor('A');
+    var constA_foo = findElement.constructor('foo', of: 'A');
     // A()
     assertThat(constA)
       ..hasRelationCount(2)
@@ -677,9 +665,8 @@
   new C.named(); // C2
 }
 ''');
-    ClassElement classA = findElement('A');
-    ConstructorElement constA = classA.constructors[0];
-    ConstructorElement constA_named = classA.constructors[1];
+    var constA = findElement.unnamedConstructor('A');
+    var constA_named = findElement.constructor('named', of: 'A');
     assertThat(constA)
       ..isReferencedAt('(); // B1', true, length: 0)
       ..isReferencedAt('(); // C1', true, length: 0);
@@ -711,8 +698,9 @@
 }
 ''');
     // has ".named()", but does not have "named()"
-    int offsetWithoutDot = findOffset('named();');
-    int offsetWithDot = findOffset('.named();');
+    var constructorName = findNode.constructorName('.named();');
+    var offsetWithoutDot = constructorName.name.offset;
+    var offsetWithDot = constructorName.period.offset;
     expect(index.usedElementOffsets, isNot(contains(offsetWithoutDot)));
     expect(index.usedElementOffsets, contains(offsetWithDot));
   }
@@ -725,9 +713,8 @@
   A.bar();
 }
 ''');
-    ClassElement classA = findElement('A');
-    ConstructorElement constA = classA.constructors[0];
-    ConstructorElement constA_bar = classA.constructors[2];
+    var constA = findElement.unnamedConstructor('A');
+    var constA_bar = findElement.constructor('bar');
     assertThat(constA).isReferencedAt('(); // 2', true, length: 0);
     assertThat(constA_bar).isReferencedAt('.bar(); // 1', true, length: 4);
   }
@@ -739,8 +726,7 @@
   new A(); // 1
 }
 ''');
-    ClassElement classA = findElement('A');
-    ConstructorElement constA = classA.constructors[0];
+    var constA = findElement.unnamedConstructor('A');
     // A()
     assertThat(constA)..isReferencedAt('(); // 1', true, length: 0);
   }
@@ -762,7 +748,7 @@
   E(0).foo();
 }
 ''');
-    ExtensionElement element = findElement('E');
+    ExtensionElement element = findElement.extension_('E');
     assertThat(element)..isReferencedAt('E(0).foo()', false);
   }
 
@@ -782,7 +768,7 @@
   new A(field: 4);
 }
 ''');
-    FieldElement field = findElement('field', ElementKind.FIELD);
+    FieldElement field = findElement.field('field');
     PropertyAccessorElement getter = field.getter;
     PropertyAccessorElement setter = field.setter;
     // A()
@@ -812,7 +798,7 @@
 ''');
     // aaa
     {
-      FieldElement field = findElement('aaa', ElementKind.FIELD);
+      FieldElement field = findElement.field('aaa');
       PropertyAccessorElement getter = field.getter;
       PropertyAccessorElement setter = field.setter;
       assertThat(field)..isWrittenAt('aaa, ', true);
@@ -821,7 +807,7 @@
     }
     // bbb
     {
-      FieldElement field = findElement('bbb', ElementKind.FIELD);
+      FieldElement field = findElement.field('bbb');
       PropertyAccessorElement getter = field.getter;
       PropertyAccessorElement setter = field.setter;
       assertThat(field)..isWrittenAt('bbb) {}', true);
@@ -842,7 +828,7 @@
   print(MyEnum.B);
 }
 ''');
-    ClassElement enumElement = findElement('MyEnum');
+    ClassElement enumElement = findElement.enum_('MyEnum');
     assertThat(enumElement.getGetter('values'))
       ..isReferencedAt('values);', true);
     assertThat(enumElement.getGetter('index'))..isReferencedAt('index);', true);
@@ -857,7 +843,7 @@
   int get f => 0;
 }
 ''');
-    ClassElement element2 = findElement('A');
+    ClassElement element2 = findElement.class_('A');
     assertThat(element2.getField('f')).isWrittenAt('f = 42', true);
   }
 
@@ -869,7 +855,7 @@
   set f(_) {}
 }
 ''');
-    ClassElement element2 = findElement('A');
+    ClassElement element2 = findElement.class_('A');
     assertThat(element2.getField('f')).isWrittenAt('f = 42', true);
   }
 
@@ -880,7 +866,7 @@
   set f(_) {}
 }
 ''');
-    ClassElement element2 = findElement('A');
+    ClassElement element2 = findElement.class_('A');
     assertThat(element2.getField('f')).isWrittenAt('f = 42', true);
   }
 
@@ -892,14 +878,14 @@
   print(foo());
 }
 ''');
-    FunctionElement element = findElement('foo');
+    FunctionElement element = findElement.topFunction('foo');
     assertThat(element)
       ..isReferencedAt('foo);', false)
       ..isInvokedAt('foo());', false);
   }
 
   test_isReferencedBy_FunctionElement_with_LibraryElement() async {
-    newFile('$testProject2/foo.dart', content: r'''
+    newFile('$testPackageLibPath/foo.dart', content: r'''
 bar() {}
 ''');
     await _indexTestUnit('''
@@ -908,12 +894,13 @@
   bar();
 }
 ''');
-    LibraryElement fooLibrary = testLibraryElement.imports[0].importedLibrary;
-    assertThat(fooLibrary)..isReferencedAt('"foo.dart";', true, length: 10);
-    {
-      FunctionElement bar = fooLibrary.definingCompilationUnit.functions[0];
-      assertThat(bar)..isInvokedAt('bar();', false);
-    }
+
+    var importFind = findElement.importFind('package:test/foo.dart');
+    assertThat(importFind.importedLibrary)
+      ..isReferencedAt('"foo.dart";', true, length: 10);
+
+    FunctionElement bar = importFind.topFunction('bar');
+    assertThat(bar)..isInvokedAt('bar();', false);
   }
 
   test_isReferencedBy_FunctionTypeAliasElement() async {
@@ -922,7 +909,7 @@
 main(A p) {
 }
 ''');
-    Element element = findElement('A');
+    Element element = findElement.typeAlias('A');
     assertThat(element)..isReferencedAt('A p) {', false);
   }
 
@@ -937,7 +924,7 @@
 /// [A] text
 var myVariable = null;
 ''');
-    Element element = findElement('A');
+    Element element = findElement.class_('A');
     assertThat(element)..isReferencedAt('A] text', false);
   }
 
@@ -950,15 +937,15 @@
     print(method); // nq
   }
 }''');
-    MethodElement element = findElement('method');
+    MethodElement element = findElement.method('method');
     assertThat(element)
       ..isReferencedAt('method); // q', true)
       ..isReferencedAt('method); // nq', false);
   }
 
   test_isReferencedBy_MultiplyDefinedElement() async {
-    newFile('$testProject2/a1.dart', content: 'class A {}');
-    newFile('$testProject2/a2.dart', content: 'class A {}');
+    newFile('$testPackageLibPath/a1.dart', content: 'class A {}');
+    newFile('$testPackageLibPath/a2.dart', content: 'class A {}');
     await _indexTestUnit('''
 import 'a1.dart';
 import 'a2.dart';
@@ -980,7 +967,7 @@
   foo(p: 1);
 }
 ''');
-    Element element = findElement('p');
+    Element element = findElement.parameter('p');
     assertThat(element)..isReferencedAt('p: 1', true);
   }
 
@@ -1035,7 +1022,7 @@
   A(test: 0);
 }
 ''');
-    Element element = findElement('test');
+    Element element = findElement.parameter('test');
     assertThat(element)..isReferencedAt('test: 0', true);
   }
 
@@ -1049,7 +1036,7 @@
   a.foo(test: 0);
 }
 ''');
-    Element element = findElement('test');
+    Element element = findElement.parameter('test');
     assertThat(element)..isReferencedAt('test: 0', true);
   }
 
@@ -1062,7 +1049,7 @@
   foo(1); // 2
 }
 ''');
-    Element element = findElement('p');
+    Element element = findElement.parameter('p');
     assertThat(element)
       ..hasRelationCount(1)
       ..isReferencedAt('1); // 2', true, length: 0);
@@ -1080,8 +1067,8 @@
   0.foo = 0;
 }
 ''');
-    PropertyAccessorElement getter = findElement('foo', ElementKind.GETTER);
-    PropertyAccessorElement setter = findElement('foo=');
+    PropertyAccessorElement getter = findElement.getter('foo');
+    PropertyAccessorElement setter = findElement.setter('foo');
     assertThat(getter)..isReferencedAt('foo;', true);
     assertThat(setter)..isReferencedAt('foo = 0;', true);
   }
@@ -1098,8 +1085,8 @@
   0.foo = 0;
 }
 ''');
-    PropertyAccessorElement getter = findElement('foo', ElementKind.GETTER);
-    PropertyAccessorElement setter = findElement('foo=');
+    PropertyAccessorElement getter = findElement.getter('foo');
+    PropertyAccessorElement setter = findElement.setter('foo');
     assertThat(getter)..isReferencedAt('foo;', true);
     assertThat(setter)..isReferencedAt('foo = 0;', true);
   }
@@ -1123,7 +1110,6 @@
   (1.2).foo = 0; // double setter ref
 }
 ''');
-    var findNode = FindNode(testCode, testUnit);
 
     var intGetter = findNode.methodDeclaration('0; // int getter');
     var intSetter = findNode.methodDeclaration('{} // int setter');
@@ -1153,7 +1139,7 @@
   }
 
   test_isReferencedBy_TopLevelVariableElement() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 library lib;
 var V;
 ''');
@@ -1166,7 +1152,7 @@
   V = 5; // nq
   print(V); // nq
 }''');
-    TopLevelVariableElement variable = importedUnit().topLevelVariables[0];
+    TopLevelVariableElement variable = importFindLib().topVar('V');
     assertThat(variable)..isReferencedAt('V; // imp', true);
     assertThat(variable.getter)
       ..isReferencedAt('V); // q', true)
@@ -1177,25 +1163,25 @@
   }
 
   test_isReferencedBy_TopLevelVariableElement_synthetic_hasGetterSetter() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 int get V => 0;
 void set V(_) {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' show V;
 ''');
-    TopLevelVariableElement element = importedUnit().topLevelVariables[0];
+    TopLevelVariableElement element = importFindLib().topVar('V');
     assertThat(element).isReferencedAt('V;', true);
   }
 
   test_isReferencedBy_TopLevelVariableElement_synthetic_hasSetter() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 void set V(_) {}
 ''');
     await _indexTestUnit('''
 import 'lib.dart' show V;
 ''');
-    TopLevelVariableElement element = importedUnit().topLevelVariables[0];
+    TopLevelVariableElement element = importFindLib().topVar('V');
     assertThat(element).isReferencedAt('V;', true);
   }
 
@@ -1204,7 +1190,7 @@
 class A {}
 A myVariable = null;
 ''');
-    Element element = findElement('A');
+    Element element = findElement.class_('A');
     assertThat(element).isReferencedAt('A myVariable', false);
   }
 
@@ -1216,7 +1202,7 @@
   A.bar() : field = 5;
 }
 ''');
-    FieldElement element = findElement('field', ElementKind.FIELD);
+    FieldElement element = findElement.field('field');
     assertThat(element)
       ..isWrittenAt('field})', true)
       ..isWrittenAt('field = 5', true);
@@ -1224,7 +1210,7 @@
 
   test_subtypes_classDeclaration() async {
     String libP = 'package:test/lib.dart;package:test/lib.dart';
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 class B {}
 class C {}
@@ -1274,7 +1260,7 @@
 
   test_subtypes_classTypeAlias() async {
     String libP = 'package:test/lib.dart;package:test/lib.dart';
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 class B {}
 class C {}
@@ -1312,7 +1298,7 @@
 
   test_subtypes_mixinDeclaration() async {
     String libP = 'package:test/lib.dart;package:test/lib.dart';
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 class A {}
 class B {}
 class C {}
@@ -1358,14 +1344,14 @@
   var x;
 }
 main(C c) {
-  c.x;
+  c.x; // 1
   c.x = 1;
   c.x += 2;
   c.x();
 }
 ''');
     assertThatName('x')
-      ..isNotUsedQ('x;', IndexRelationKind.IS_READ_BY)
+      ..isNotUsedQ('x; // 1', IndexRelationKind.IS_READ_BY)
       ..isNotUsedQ('x = 1;', IndexRelationKind.IS_WRITTEN_BY)
       ..isNotUsedQ('x += 2;', IndexRelationKind.IS_READ_WRITTEN_BY)
       ..isNotUsedQ('x();', IndexRelationKind.IS_INVOKED_BY);
@@ -1392,7 +1378,7 @@
 class C {
   var x;
   m() {
-    x;
+    x; // 1
     x = 1;
     x += 2;
     x();
@@ -1400,7 +1386,7 @@
 }
 ''');
     assertThatName('x')
-      ..isNotUsedQ('x;', IndexRelationKind.IS_READ_BY)
+      ..isNotUsedQ('x; // 1', IndexRelationKind.IS_READ_BY)
       ..isNotUsedQ('x = 1;', IndexRelationKind.IS_WRITTEN_BY)
       ..isNotUsedQ('x += 2;', IndexRelationKind.IS_READ_WRITTEN_BY)
       ..isNotUsedQ('x();', IndexRelationKind.IS_INVOKED_BY);
@@ -1474,9 +1460,9 @@
 
   ExpectedLocation _expectedLocation(String search, bool isQualified,
       {int length}) {
-    int offset = findOffset(search);
-    length ??= getLeadingIdentifierLength(search);
-    return ExpectedLocation(testUnitElement, offset, length, isQualified);
+    int offset = findNode.offset(search);
+    length ??= findNode.simple(search).length;
+    return ExpectedLocation(offset, length, isQualified);
   }
 
   void _failWithIndexDump(String msg) {
@@ -1564,15 +1550,10 @@
   }
 
   Future<void> _indexTestUnit(String code) async {
-    addTestFile(code);
+    await resolveTestCode(code);
 
-    ResolvedUnitResult result = await driver.getResult(testFile);
-    testUnit = result.unit;
-    testUnitElement = testUnit.declaredElement;
-    testLibraryElement = testUnitElement.library;
-
-    AnalysisDriverUnitIndexBuilder indexBuilder = indexUnit(testUnit);
-    List<int> indexBytes = indexBuilder.toBuffer();
+    var indexBuilder = indexUnit(result.unit);
+    var indexBytes = indexBuilder.toBuffer();
     index = AnalysisDriverUnitIndex.fromBuffer(indexBytes);
   }
 }
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
index 3858d02..98b60a3 100644
--- a/pkg/analyzer/test/src/dart/analysis/search_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -1115,7 +1115,7 @@
 ''');
     var element = findElement.prefix('ppp');
     var main = findElement.function('main');
-    Element c = findChildElement(testLibraryElement, 'c');
+    var c = findElement.partFind('my_part.dart').topVar('c');
     var expected = [
       _expectId(main, SearchResultKind.REFERENCE, 'ppp.Future'),
       _expectId(main, SearchResultKind.REFERENCE, 'ppp.Stream'),
@@ -1145,7 +1145,7 @@
 ''', addToDriver: false);
     var element = findElement.prefix('ppp');
     var main = findElement.function('main');
-    Element c = findChildElement(testLibraryElement, 'c');
+    var c = findElement.partFind('my_part.dart').topVar('c');
     var expected = [
       _expectId(main, SearchResultKind.REFERENCE, 'ppp.Future'),
       _expectId(main, SearchResultKind.REFERENCE, 'ppp.Stream'),
diff --git a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
index ee34035..f5bd0cd 100644
--- a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
@@ -238,22 +238,19 @@
 
     assertSimpleIdentifier(
       findNode.simple('a['),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       findNode.simple('b]'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -281,22 +278,19 @@
 
     assertSimpleIdentifier(
       findNode.simple('a['),
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'int',
     );
 
     assertSimpleIdentifier(
       findNode.simple('b]'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -327,22 +321,19 @@
 
     assertSimpleIdentifier(
       findNode.simple('a['),
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'A',
     );
 
     assertSimpleIdentifier(
       findNode.simple('b]'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -420,22 +411,19 @@
 
     assertSimpleIdentifier(
       findNode.simple('a + b'),
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'int',
     );
 
     assertSimpleIdentifier(
       findNode.simple('b)'),
-      readElement: findElement.parameter('b'),
-      writeElement: null,
+      element: findElement.parameter('b'),
       type: 'int',
     );
 
     assertSimpleIdentifier(
       findNode.simple('c;'),
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'double',
     );
   }
@@ -462,8 +450,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -490,8 +477,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -518,8 +504,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -546,8 +531,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -574,8 +558,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -602,8 +585,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('y;'),
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -639,9 +621,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: matcherC,
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -671,9 +650,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.class_('C'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -720,9 +696,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: findElement.getter('x'),
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -753,9 +726,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -788,9 +758,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: null,
-      writeElement: findElement.getter('x'),
-      type: 'dynamic',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -821,9 +788,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -856,9 +820,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: null,
-      writeElement: findElement.getter('x'),
-      type: 'dynamic',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -898,9 +859,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: importFind.topGet('x'),
-      writeElement: importFind.topSet('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -928,22 +886,17 @@
 
     assertSimpleIdentifier(
       findNode.simple('a.'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       findNode.simple('b ='),
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -971,22 +924,17 @@
 
     assertSimpleIdentifier(
       findNode.simple('a.'),
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'int',
     );
 
     assertSimpleIdentifierAssignmentTarget(
       findNode.simple('b +='),
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -1020,9 +968,6 @@
     var propertyAccess = assignment.leftHandSide as PropertyAccess;
     assertSimpleIdentifierAssignmentTarget(
       propertyAccess.propertyName,
-      readElement: findElement.getter('x'),
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1085,9 +1030,6 @@
     var propertyAccess = assignment.leftHandSide as PropertyAccess;
     assertSimpleIdentifierAssignmentTarget(
       propertyAccess.propertyName,
-      readElement: findElement.getter('x'),
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1155,9 +1097,6 @@
     var propertyAccess = assignment.leftHandSide as PropertyAccess;
     assertSimpleIdentifierAssignmentTarget(
       propertyAccess.propertyName,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1198,9 +1137,6 @@
     assertSuperExpression(propertyAccess.target);
     assertSimpleIdentifierAssignmentTarget(
       propertyAccess.propertyName,
-      readElement: findElement.getter('x', of: 'A'),
-      writeElement: findElement.setter('x', of: 'A'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1235,9 +1171,6 @@
     var propertyAccess = assignment.leftHandSide as PropertyAccess;
     assertSimpleIdentifierAssignmentTarget(
       propertyAccess.propertyName,
-      readElement: findElement.getter('x'),
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1265,22 +1198,17 @@
 
     assertSimpleIdentifier(
       findNode.simple('a)'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       findNode.simple('b ='),
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       findNode.simple('c;'),
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -1307,22 +1235,17 @@
 
     assertSimpleIdentifier(
       findNode.simple('a)'),
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       findNode.simple('b ='),
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       findNode.simple('c;'),
-      readElement: findElement.parameter('c'),
-      writeElement: null,
+      element: findElement.parameter('c'),
       type: 'int',
     );
   }
@@ -1351,9 +1274,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1383,9 +1303,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1417,9 +1334,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.getter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1451,9 +1365,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.getter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1483,9 +1394,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topGet('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1522,9 +1430,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.prefix('x'),
-      type: null,
     );
   }
 
@@ -1552,9 +1457,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.prefix('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1585,9 +1487,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.localVar('x'),
-      writeElement: findElement.localVar('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1613,11 +1512,8 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.localVar('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1645,11 +1541,8 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.localVar('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1677,11 +1570,8 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.localVar('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1708,9 +1598,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.parameter('x'),
-      writeElement: findElement.parameter('x'),
-      type: 'num$question',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1744,9 +1631,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.parameter('x'),
-      writeElement: findElement.parameter('x'),
-      type: 'B$question',
     );
 
     assertType(assignment.rightHandSide, 'C');
@@ -1776,15 +1660,11 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.parameter('a'),
-      writeElement: findElement.parameter('a'),
-      type: 'double$question',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('b'),
-      writeElement: null,
+      element: findElement.parameter('b'),
       type: 'int',
     );
   }
@@ -1844,11 +1724,8 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.parameter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1879,11 +1756,8 @@
       type: expectedType,
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.parameter('x'),
-      type: 'Object',
     );
 
     assertType(assignment.rightHandSide, expectedType);
@@ -1909,11 +1783,8 @@
       type: 'bool',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.parameter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'bool');
@@ -1939,11 +1810,8 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.parameter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -1980,9 +1848,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.getter('x', of: 'B'),
-      type: null,
     );
   }
 
@@ -2017,9 +1882,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.method('x', of: 'B'),
-      type: null,
     );
   }
 
@@ -2049,9 +1911,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.setter('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2077,17 +1936,13 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('y'),
-      writeElement: null,
+      element: findElement.parameter('y'),
       type: 'int',
     );
   }
@@ -2120,9 +1975,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.setter('x', of: 'A'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2156,9 +2008,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.getter('x'),
-      writeElement: findElement.setter('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2199,9 +2048,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.getter('x', of: 'M2'),
-      writeElement: findElement.setter('x', of: 'M2'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2238,9 +2084,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topGet('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2272,9 +2115,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.topGet('x'),
-      writeElement: findElement.topSet('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2310,9 +2150,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.topGet('x'),
-      writeElement: findElement.topSet('x'),
-      type: 'B$question',
     );
 
     assertType(assignment.rightHandSide, 'C');
@@ -2346,9 +2183,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: findElement.topGet('x'),
-      writeElement: findElement.topSet('x'),
-      type: 'num',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2376,9 +2210,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topSet('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2408,9 +2239,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topSet('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'bool');
@@ -2440,9 +2268,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: findElement.topGet('x'),
-      type: null,
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2470,9 +2295,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: intElement,
-      type: 'dynamic',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2500,9 +2322,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: intElement,
-      type: 'Type',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2530,9 +2349,6 @@
 
     assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertType(assignment.rightHandSide, 'int');
@@ -2558,17 +2374,13 @@
       type: 'int',
     );
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       assignment.leftHandSide,
-      readElement: null,
-      writeElement: null,
-      type: null,
     );
 
     assertSimpleIdentifier(
       assignment.rightHandSide,
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'int',
     );
   }
@@ -2608,9 +2420,6 @@
     var prefixed = assignment.leftHandSide as PrefixedIdentifier;
     assertSimpleIdentifierAssignmentTarget(
       prefixed.identifier,
-      readElement: null,
-      writeElement: null,
-      type: 'dynamic',
     );
 
     assertType(assignment.rightHandSide, 'int');
diff --git a/pkg/analyzer/test/src/dart/resolution/constant_test.dart b/pkg/analyzer/test/src/dart/resolution/constant_test.dart
index 4090683..da6c9ff 100644
--- a/pkg/analyzer/test/src/dart/resolution/constant_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/constant_test.dart
@@ -131,9 +131,10 @@
 
     // The element and type arguments are available for the function type.
     var importFind = findElement.importFind('package:test/a.dart');
-    var elementF = importFind.functionTypeAlias('F');
-    expect(typeArgument.element, elementF.function);
-    expect(typeArgument.element.enclosingElement, elementF);
+    var alias = importFind.functionTypeAlias('F');
+    var aliasedElement = alias.aliasedElement as GenericFunctionTypeElement;
+    expect(typeArgument.element, aliasedElement);
+    expect(typeArgument.element.enclosingElement, alias);
     assertElementTypeStrings(typeArgument.typeArguments, ['double']);
   }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/function_type_alias_test.dart b/pkg/analyzer/test/src/dart/resolution/function_type_alias_test.dart
index b612327..5a169e7 100644
--- a/pkg/analyzer/test/src/dart/resolution/function_type_alias_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/function_type_alias_test.dart
@@ -2,6 +2,7 @@
 // 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/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -26,7 +27,7 @@
     assertType(type, 'int Function()');
 
     var typedefG = findElement.functionTypeAlias('G');
-    var functionG = typedefG.function;
+    var functionG = typedefG.aliasedElement as GenericFunctionTypeElement;
 
     expect(type.element, functionG);
     expect(type.element?.enclosingElement, typedefG);
diff --git a/pkg/analyzer/test/src/dart/resolution/generic_type_alias_test.dart b/pkg/analyzer/test/src/dart/resolution/generic_type_alias_test.dart
index f743dcf..3762cb3 100644
--- a/pkg/analyzer/test/src/dart/resolution/generic_type_alias_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/generic_type_alias_test.dart
@@ -2,6 +2,7 @@
 // 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/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -152,7 +153,7 @@
     assertType(type, 'int Function(double)');
 
     var typedefG = findElement.functionTypeAlias('G');
-    var functionG = typedefG.function;
+    var functionG = typedefG.aliasedElement as GenericFunctionTypeElement;
 
     expect(type.element, functionG);
     expect(type.element?.enclosingElement, typedefG);
@@ -175,7 +176,7 @@
     expect(t.name, 'T');
     assertType(t.bound, 'A');
 
-    var ff = f.function;
+    var ff = f.aliasedElement as GenericFunctionTypeElement;
     expect(ff.typeParameters, hasLength(1));
 
     var u = ff.typeParameters[0];
diff --git a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
index 400c242..ba93f9f 100644
--- a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
@@ -179,14 +179,9 @@
       type: 'dynamic',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        postfix.operand,
-        readElement: findElement.typeParameter('T'),
-        writeElement: findElement.typeParameter('T'),
-        type: 'dynamic',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      postfix.operand,
+    );
   }
 
   test_inc_prefixedIdentifier_instance() async {
@@ -419,14 +414,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        postfix.operand,
-        readElement: findElement.getter('x'),
-        writeElement: findElement.setter('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      postfix.operand,
+    );
   }
 
   test_inc_simpleIdentifier_topGetter_topSetter() async {
@@ -454,14 +444,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        postfix.operand,
-        readElement: findElement.topGet('x'),
-        writeElement: findElement.topSet('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      postfix.operand,
+    );
   }
 
   test_inc_simpleIdentifier_topGetter_topSetter_fromClass() async {
@@ -491,14 +476,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        postfix.operand,
-        readElement: findElement.topGet('x'),
-        writeElement: findElement.topSet('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      postfix.operand,
+    );
   }
 }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
index 671e345..33a2b3c 100644
--- a/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
@@ -491,14 +491,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefix.operand,
-        readElement: findElement.getter('x'),
-        writeElement: findElement.setter('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefix.operand,
+    );
   }
 
   test_plusPlus_simpleIdentifier_thisGetter_thisSetter() async {
@@ -526,14 +521,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefix.operand,
-        readElement: findElement.getter('x'),
-        writeElement: findElement.setter('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefix.operand,
+    );
   }
 
   test_plusPlus_simpleIdentifier_topGetter_topSetter() async {
@@ -561,14 +551,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefix.operand,
-        readElement: findElement.topGet('x'),
-        writeElement: findElement.topSet('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefix.operand,
+    );
   }
 
   test_plusPlus_simpleIdentifier_topGetter_topSetter_fromClass() async {
@@ -598,14 +583,9 @@
       type: 'int',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefix.operand,
-        readElement: findElement.topGet('x'),
-        writeElement: findElement.topSet('x'),
-        type: 'num',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefix.operand,
+    );
   }
 
   /// Verify that we get all necessary types when building the dependencies
diff --git a/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart b/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
index b952a96..37f0d93 100644
--- a/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/prefixed_identifier_test.dart
@@ -94,15 +94,13 @@
 
     assertSimpleIdentifier(
       prefixed.prefix,
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'A',
     );
 
     assertSimpleIdentifier(
       prefixed.identifier,
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
@@ -127,15 +125,13 @@
 
     assertSimpleIdentifier(
       prefixed.prefix,
-      readElement: findElement.class_('A'),
-      writeElement: null,
+      element: findElement.class_('A'),
       type: null,
     );
 
     assertSimpleIdentifier(
       prefixed.identifier,
-      readElement: findElement.method('foo'),
-      writeElement: null,
+      element: findElement.method('foo'),
       type: 'void Function<U>(int, U)',
     );
   }
@@ -160,15 +156,13 @@
 
     assertSimpleIdentifier(
       prefixed.prefix,
-      readElement: findElement.class_('A'),
-      writeElement: null,
+      element: findElement.class_('A'),
       type: null,
     );
 
     assertSimpleIdentifier(
       prefixed.identifier,
-      readElement: findElement.method('foo'),
-      writeElement: null,
+      element: findElement.method('foo'),
       type: 'void Function(int)',
     );
   }
@@ -209,19 +203,13 @@
 
     assertSimpleIdentifier(
       prefixed.prefix,
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'A',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefixed.identifier,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefixed.identifier,
+    );
   }
 
   test_write() async {
@@ -257,19 +245,13 @@
 
     assertSimpleIdentifier(
       prefixed.prefix,
-      readElement: findElement.parameter('a'),
-      writeElement: null,
+      element: findElement.parameter('a'),
       type: 'A',
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        prefixed.identifier,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      prefixed.identifier,
+    );
   }
 }
 
@@ -302,8 +284,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('foo;'),
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
diff --git a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
index e1724a4..c6e60f7 100644
--- a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
@@ -39,8 +39,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
@@ -114,14 +113,11 @@
         element: findElement.setter('foo'),
         type: 'int',
       );
-
-      assertSimpleIdentifier(
-        propertyAccess.propertyName,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
     }
+
+    assertSimpleIdentifierAssignmentTarget(
+      propertyAccess.propertyName,
+    );
   }
 
   test_functionType_call_read() async {
@@ -158,8 +154,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
@@ -228,14 +223,11 @@
         element: findElement.setter('foo'),
         type: 'int',
       );
-
-      assertSimpleIdentifier(
-        propertyAccess.propertyName,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
     }
+
+    assertSimpleIdentifierAssignmentTarget(
+      propertyAccess.propertyName,
+    );
   }
 
   test_invalid_inDefaultValue_nullAware() async {
@@ -296,8 +288,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
@@ -371,14 +362,11 @@
         element: findElement.setter('foo'),
         type: 'int',
       );
-
-      assertSimpleIdentifier(
-        propertyAccess.propertyName,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
     }
+
+    assertSimpleIdentifierAssignmentTarget(
+      propertyAccess.propertyName,
+    );
   }
 
   test_super_read() async {
@@ -407,8 +395,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: findElement.getter('foo'),
-      writeElement: null,
+      element: findElement.getter('foo'),
       type: 'int',
     );
   }
@@ -453,14 +440,9 @@
       propertyAccess.target,
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        propertyAccess.propertyName,
-        readElement: findElement.getter('foo'),
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      propertyAccess.propertyName,
+    );
   }
 
   test_super_write() async {
@@ -500,14 +482,9 @@
       propertyAccess.target,
     );
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        propertyAccess.propertyName,
-        readElement: null,
-        writeElement: findElement.setter('foo'),
-        type: 'int',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      propertyAccess.propertyName,
+    );
   }
 
   test_targetTypeParameter_dynamicBounded() async {
@@ -528,8 +505,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
   }
@@ -560,8 +536,7 @@
 
     assertSimpleIdentifier(
       propertyAccess.propertyName,
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
   }
@@ -714,8 +689,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('foo?'),
-      readElement: findElement.topGet('foo'),
-      writeElement: null,
+      element: findElement.topGet('foo'),
       type: 'A?',
     );
 
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 3b735c3..0b33c271 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -343,7 +343,10 @@
     @required FunctionTypeAliasElement element,
     @required List<String> typeArguments,
   }) {
-    assertElement2(type.element, declaration: element.function);
+    assertElement2(
+      type.element,
+      declaration: element.aliasedElement as GenericFunctionTypeElement,
+    );
     assertElementTypeStrings(type.typeArguments, typeArguments);
   }
 
@@ -659,53 +662,22 @@
 
   void assertSimpleIdentifier(
     SimpleIdentifier node, {
-    @required Object readElement,
-    @required Object writeElement,
+    @required Object element,
     @required String type,
   }) {
     var isRead = node.inGetterContext();
-    var isWrite = node.inSetterContext();
-    if (isRead && isWrite) {
-      // TODO(scheglov) enable this
-//      assertElement(node.auxiliaryElements?.staticElement, readElement);
-      assertElement(node.staticElement, writeElement);
-    } else if (isRead) {
-      assertElement(node.staticElement, readElement);
-    } else {
-      expect(isWrite, isTrue);
-      assertElement(node.staticElement, writeElement);
-    }
+    expect(isRead, isTrue);
 
-    if (isRead) {
-      assertType(node, type);
-    } else {
-      // TODO(scheglov) enforce this
-//      expect(type, isNull);
-//      assertTypeNull(node);
-    }
+    assertElement(node.staticElement, element);
+    assertType(node, type);
   }
 
   /// TODO(scheglov) https://github.com/dart-lang/sdk/issues/43608
-  /// TODO(scheglov) rename this method
-  void assertSimpleIdentifierAssignmentTarget(
-    SimpleIdentifier node, {
-    @required Object readElement,
-    @required Object writeElement,
-    @required String type,
-  }) {
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        node,
-        readElement: readElement,
-        writeElement: writeElement,
-        type: type,
-      );
-    } else {
-      // TODO(scheglov) Enforce maybe?
-      // Currently VariableResolverVisitor sets it.
-      // expect(node.staticElement, isNull);
-      expect(node.staticType, isNull);
-    }
+  void assertSimpleIdentifierAssignmentTarget(SimpleIdentifier node) {
+    // TODO(scheglov) Enforce maybe?
+    // Currently VariableResolverVisitor sets it.
+    // expect(node.staticElement, isNull);
+    expect(node.staticType, isNull);
   }
 
   void assertSubstitution(
diff --git a/pkg/analyzer/test/src/dart/resolution/simple_identifier_test.dart b/pkg/analyzer/test/src/dart/resolution/simple_identifier_test.dart
index 88deb9e..9d01ef1 100644
--- a/pkg/analyzer/test/src/dart/resolution/simple_identifier_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/simple_identifier_test.dart
@@ -27,8 +27,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('dynamic;'),
-      readElement: dynamicElement,
-      writeElement: null,
+      element: dynamicElement,
       type: 'Type',
     );
   }
@@ -46,8 +45,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('dynamic;'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
   }
@@ -61,8 +59,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('dynamic;'),
-      readElement: dynamicElement,
-      writeElement: null,
+      element: dynamicElement,
       type: 'Type',
     );
   }
diff --git a/pkg/analyzer/test/src/diagnostics/receiver_of_type_never_test.dart b/pkg/analyzer/test/src/diagnostics/receiver_of_type_never_test.dart
index 757d377..00ed468 100644
--- a/pkg/analyzer/test/src/diagnostics/receiver_of_type_never_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/receiver_of_type_never_test.dart
@@ -422,8 +422,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('foo'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'Never',
     );
   }
@@ -437,8 +436,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('hashCode'),
-      readElement: objectElement.getGetter('hashCode'),
-      writeElement: null,
+      element: objectElement.getGetter('hashCode'),
       type: 'Never',
     );
   }
@@ -452,14 +450,9 @@
       error(HintCode.DEAD_CODE, 29, 2),
     ]);
 
-    if (hasAssignmentLeftResolution) {
-      assertSimpleIdentifier(
-        findNode.simple('foo'),
-        readElement: null,
-        writeElement: null,
-        type: 'dynamic',
-      );
-    }
+    assertSimpleIdentifierAssignmentTarget(
+      findNode.simple('foo'),
+    );
 
     assertAssignment(
       findNode.assignment('foo += 0'),
@@ -481,8 +474,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('toString'),
-      readElement: objectElement.getMethod('toString'),
-      writeElement: null,
+      element: objectElement.getMethod('toString'),
       type: 'Never',
     );
   }
@@ -496,11 +488,8 @@
       error(HintCode.DEAD_CODE, 28, 2),
     ]);
 
-    assertSimpleIdentifier(
+    assertSimpleIdentifierAssignmentTarget(
       findNode.simple('foo'),
-      readElement: null,
-      writeElement: null,
-      type: 'Never',
     );
 
     assertAssignment(
@@ -525,8 +514,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('foo'),
-      readElement: null,
-      writeElement: null,
+      element: null,
       type: 'dynamic',
     );
   }
@@ -540,8 +528,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('hashCode'),
-      readElement: objectElement.getGetter('hashCode'),
-      writeElement: null,
+      element: objectElement.getGetter('hashCode'),
       type: 'int',
     );
   }
@@ -555,8 +542,7 @@
 
     assertSimpleIdentifier(
       findNode.simple('toString'),
-      readElement: objectElement.getMethod('toString'),
-      writeElement: null,
+      element: objectElement.getMethod('toString'),
       type: 'String Function()',
     );
   }
@@ -623,11 +609,10 @@
 
     assertSimpleIdentifier(
       findNode.simple('toString'),
-      readElement: elementMatcher(
+      element: elementMatcher(
         objectElement.getMethod('toString'),
         isLegacy: isNullSafetySdkAndLegacyLibrary,
       ),
-      writeElement: null,
       type: 'String Function()',
     );
   }
@@ -641,11 +626,10 @@
 
     assertSimpleIdentifier(
       findNode.simple('hashCode'),
-      readElement: elementMatcher(
+      element: elementMatcher(
         objectElement.getGetter('hashCode'),
         isLegacy: isNullSafetySdkAndLegacyLibrary,
       ),
-      writeElement: null,
       type: 'int',
     );
   }
diff --git a/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart b/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
index aaa54e9..5c1a04d 100644
--- a/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
@@ -886,8 +886,7 @@
     ]);
     assertSimpleIdentifier(
       findNode.simple('isEven'),
-      readElement: intElement.getGetter('isEven'),
-      writeElement: null,
+      element: intElement.getGetter('isEven'),
       type: 'bool',
     );
   }
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 3e5d249..99a5202 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -7199,7 +7199,7 @@
     expect(T.name, 'T');
     expect(T.enclosingElement, same(F));
 
-    var function = F.function;
+    var function = F.aliasedElement as GenericFunctionTypeElement;
     expect(function.enclosingElement, same(F));
 
     var a = function.parameters[0];
@@ -7523,7 +7523,7 @@
     expect(T.name, 'T');
     expect(T.enclosingElement, same(F));
 
-    var function = F.function;
+    var function = F.aliasedElement as GenericFunctionTypeElement;
     expect(function.enclosingElement, same(F));
 
     var U = function.typeParameters[0];
diff --git a/pkg/analyzer_plugin/lib/src/utilities/completion/suggestion_builder.dart b/pkg/analyzer_plugin/lib/src/utilities/completion/suggestion_builder.dart
index cea8688..946ad5b 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/completion/suggestion_builder.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/completion/suggestion_builder.dart
@@ -139,9 +139,14 @@
       return type != null
           ? type.getDisplayString(withNullability: false)
           : 'dynamic';
-    } else if (element is FunctionTypeAliasElement) {
-      var returnType = element.function.returnType;
-      return returnType.getDisplayString(withNullability: false);
+    } else if (element is TypeAliasElement) {
+      var aliasedElement = element.aliasedElement;
+      if (aliasedElement is GenericFunctionTypeElement) {
+        var returnType = aliasedElement.returnType;
+        return returnType.getDisplayString(withNullability: false);
+      } else {
+        return null;
+      }
     } else {
       return null;
     }
diff --git a/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart b/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
index a46f3bd..bd4f5a5 100644
--- a/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
+++ b/pkg/analyzer_plugin/lib/utilities/analyzer_converter.dart
@@ -233,8 +233,13 @@
         return null;
       }
       parameters = element.parameters;
-    } else if (element is analyzer.FunctionTypeAliasElement) {
-      parameters = element.function.parameters;
+    } else if (element is analyzer.TypeAliasElement) {
+      var aliasedElement = element.aliasedElement;
+      if (aliasedElement is analyzer.GenericFunctionTypeElement) {
+        parameters = aliasedElement.parameters;
+      } else {
+        return null;
+      }
     } else {
       return null;
     }
@@ -275,9 +280,14 @@
       return type != null
           ? type.getDisplayString(withNullability: false)
           : 'dynamic';
-    } else if (element is analyzer.FunctionTypeAliasElement) {
-      var returnType = element.function.returnType;
-      return returnType.getDisplayString(withNullability: false);
+    } else if (element is analyzer.TypeAliasElement) {
+      var aliasedElement = element.aliasedElement;
+      if (aliasedElement is analyzer.GenericFunctionTypeElement) {
+        var returnType = aliasedElement.returnType;
+        return returnType.getDisplayString(withNullability: false);
+      } else {
+        return null;
+      }
     }
     return null;
   }
diff --git a/pkg/compiler/lib/src/kernel/env.dart b/pkg/compiler/lib/src/kernel/env.dart
index 082be52..3f042bd 100644
--- a/pkg/compiler/lib/src/kernel/env.dart
+++ b/pkg/compiler/lib/src/kernel/env.dart
@@ -313,55 +313,6 @@
     return _isSuperMixinApplication;
   }
 
-  /// Copied from 'package:kernel/transformations/mixin_full_resolution.dart'.
-  ir.Constructor _buildForwardingConstructor(
-      CloneVisitorNotMembers cloner, ir.Constructor superclassConstructor) {
-    var superFunction = superclassConstructor.function;
-
-    // We keep types and default values for the parameters but always mark the
-    // parameters as final (since we just forward them to the super
-    // constructor).
-    ir.VariableDeclaration cloneVariable(ir.VariableDeclaration variable) {
-      ir.VariableDeclaration clone = cloner.clone(variable);
-      clone.isFinal = true;
-      return clone;
-    }
-
-    // Build a [FunctionNode] which has the same parameters as the one in the
-    // superclass constructor.
-    var positionalParameters =
-        superFunction.positionalParameters.map(cloneVariable).toList();
-    var namedParameters =
-        superFunction.namedParameters.map(cloneVariable).toList();
-    var function = new ir.FunctionNode(new ir.EmptyStatement(),
-        positionalParameters: positionalParameters,
-        namedParameters: namedParameters,
-        requiredParameterCount: superFunction.requiredParameterCount,
-        returnType: const ir.VoidType());
-
-    // Build a [SuperInitializer] which takes all positional/named parameters
-    // and forward them to the super class constructor.
-    var positionalArguments = <ir.Expression>[];
-    for (var variable in positionalParameters) {
-      positionalArguments.add(new ir.VariableGet(variable));
-    }
-    var namedArguments = <ir.NamedExpression>[];
-    for (var variable in namedParameters) {
-      namedArguments.add(
-          new ir.NamedExpression(variable.name, new ir.VariableGet(variable)));
-    }
-    var superInitializer = new ir.SuperInitializer(superclassConstructor,
-        new ir.Arguments(positionalArguments, named: namedArguments));
-
-    // Assemble the constructor
-    // TODO(jensj): Provide a "reference" if we need to support
-    // the incremental compiler.
-    return new ir.Constructor(function,
-        name: superclassConstructor.name,
-        initializers: <ir.Initializer>[superInitializer],
-        reference: null);
-  }
-
   @override
   void ensureMembers(KernelToElementMapImpl elementMap) {
     _ensureMaps(elementMap);
@@ -467,31 +418,6 @@
           includeStatic: true, includeNoSuchMethodForwarders: true);
     }
 
-    if (isUnnamedMixinApplication && _constructorMap.isEmpty) {
-      // Ensure that constructors are created for the superclass in case it
-      // is also an unnamed mixin application.
-      ClassEntity superclass = elementMap.getClass(cls.superclass);
-      elementMap.elementEnvironment.lookupConstructor(superclass, '');
-
-      // Unnamed mixin applications have no constructors when read from .dill.
-      // For each generative constructor in the superclass we make a
-      // corresponding forwarding constructor in the subclass.
-      //
-      // This code is copied from
-      // 'package:kernel/transformations/mixin_full_resolution.dart'
-      var superclassSubstitution = getSubstitutionMap(cls.supertype);
-      var superclassCloner =
-          new CloneVisitorNotMembers(typeSubstitution: superclassSubstitution);
-
-      for (var superclassConstructor in cls.superclass.constructors) {
-        var forwardingConstructor = _buildForwardingConstructor(
-            superclassCloner, superclassConstructor);
-        cls.addConstructor(forwardingConstructor);
-        _constructorMap[forwardingConstructor.name.text] =
-            forwardingConstructor;
-      }
-    }
-
     mergeSort(members, start: mixinMemberCount, compare: orderByFileOffset);
     _members = members;
   }
diff --git a/pkg/nnbd_migration/bin/migrate.dart b/pkg/nnbd_migration/bin/migrate.dart
index 5401871..ee52742 100644
--- a/pkg/nnbd_migration/bin/migrate.dart
+++ b/pkg/nnbd_migration/bin/migrate.dart
@@ -7,7 +7,7 @@
 import 'package:args/src/arg_results.dart';
 import 'package:nnbd_migration/migration_cli.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   var cli = MigrationCli(binaryName: 'nnbd_migration');
   ArgResults argResults;
   try {
diff --git a/pkg/nnbd_migration/lib/nnbd_migration.dart b/pkg/nnbd_migration/lib/nnbd_migration.dart
index 25499a8..a05c09f 100644
--- a/pkg/nnbd_migration/lib/nnbd_migration.dart
+++ b/pkg/nnbd_migration/lib/nnbd_migration.dart
@@ -254,13 +254,13 @@
   }
 
   @override
-  operator ==(Object other) =>
+  bool operator ==(Object other) =>
       other is NullabilityFixDescription &&
       appliedMessage == other.appliedMessage &&
       kind == other.kind;
 
   @override
-  toString() =>
+  String toString() =>
       'NullabilityFixDescription(${json.encode(appliedMessage)}, $kind)';
 }
 
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index b348db7..15215b6 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -1742,8 +1742,10 @@
       _typeNameNesting++;
       var typeArguments = typeName.typeArguments?.arguments;
       var element = typeName.name.staticElement;
-      if (element is FunctionTypeAliasElement) {
-        final typedefType = _variables.decoratedElementType(element.function);
+      if (element is TypeAliasElement) {
+        var aliasedElement =
+            element.aliasedElement as GenericFunctionTypeElement;
+        final typedefType = _variables.decoratedElementType(aliasedElement);
         final typeNameType =
             _variables.decoratedTypeAnnotation(source, typeName);
 
diff --git a/pkg/nnbd_migration/lib/src/fix_aggregator.dart b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
index 2105912..6e57d8d 100644
--- a/pkg/nnbd_migration/lib/src/fix_aggregator.dart
+++ b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
@@ -218,7 +218,7 @@
   Iterable<String> get _toStringParts => const [];
 
   @override
-  toString() => '$runtimeType(${_toStringParts.join(', ')})';
+  String toString() => '$runtimeType(${_toStringParts.join(', ')})';
 
   /// Applies this change to the given [node], producing an [EditPlan].  The
   /// [aggregator] may be used to gather up any edits to the node's descendants
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 ec1f3b3..dae9a67 100644
--- a/pkg/nnbd_migration/lib/src/front_end/migration_info.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/migration_info.dart
@@ -156,7 +156,7 @@
   int get hashCode => JenkinsSmiHash.hash3(filePath.hashCode, offset, length);
 
   @override
-  bool operator ==(other) {
+  bool operator ==(Object other) {
     return other is NavigationTarget &&
         other.filePath == filePath &&
         other.offset == offset &&
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 f515a86..2e29d11 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
@@ -7707,7 +7707,7 @@
 ''';
 
 String _migration_js;
-// migration_dart md5 is 'bd3cb900c20bb88827f4de1cfe559484'
+// migration_dart md5 is 'e5c9686f5a2c07fa1e96ca52e558fbd0'
 String _migration_js_base64 = '''
 KGZ1bmN0aW9uIGRhcnRQcm9ncmFtKCl7ZnVuY3Rpb24gY29weVByb3BlcnRpZXMoYSxiKXt2YXIgcz1P
 YmplY3Qua2V5cyhhKQpmb3IodmFyIHI9MDtyPHMubGVuZ3RoO3IrKyl7dmFyIHE9c1tyXQpiW3FdPWFb
@@ -7797,9 +7797,9 @@
 Yy5DKCJHTTwwPiIpKSkKcmV0dXJuIGF9LApxQzpmdW5jdGlvbihhLGIsYyxkKXtQLmsxKGIsInN0YXJ0
 IikKaWYoYyE9bnVsbCl7UC5rMShjLCJlbmQiKQppZihiPmMpSC52KFAuVEUoYiwwLGMsInN0YXJ0Iixu
 dWxsKSl9cmV0dXJuIG5ldyBILm5IKGEsYixjLGQuQygibkg8MD4iKSl9LApLMTpmdW5jdGlvbihhLGIs
-YyxkKXtpZih0LmIuYihhKSlyZXR1cm4gbmV3IEgueHkoYSxiLGMuQygiQDwwPiIpLktxKGQpLkMoInh5
+YyxkKXtpZih0LmQuYihhKSlyZXR1cm4gbmV3IEgueHkoYSxiLGMuQygiQDwwPiIpLktxKGQpLkMoInh5
 PDEsMj4iKSkKcmV0dXJuIG5ldyBILmkxKGEsYixjLkMoIkA8MD4iKS5LcShkKS5DKCJpMTwxLDI+Iikp
-fSwKYks6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPSJjb3VudCIKaWYodC5iLmIoYSkpe1AuTVIoYixzLHQu
+fSwKYks6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPSJjb3VudCIKaWYodC5kLmIoYSkpe1AuTVIoYixzLHQu
 UykKUC5rMShiLHMpCnJldHVybiBuZXcgSC5kNShhLGIsYy5DKCJkNTwwPiIpKX1QLk1SKGIscyx0LlMp
 ClAuazEoYixzKQpyZXR1cm4gbmV3IEguQU0oYSxiLGMuQygiQU08MD4iKSl9LApXcDpmdW5jdGlvbigp
 e3JldHVybiBuZXcgUC5saigiTm8gZWxlbWVudCIpfSwKQW06ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFAu
@@ -8166,7 +8166,7 @@
 cm4gc31yZXR1cm4gSC56KGEpfSwKejpmdW5jdGlvbihhKXt2YXIgcwppZihhIGluc3RhbmNlb2YgUC5N
 aCl7cz1hLiR0aQpyZXR1cm4gcyE9bnVsbD9zOkguVlUoYSl9aWYoQXJyYXkuaXNBcnJheShhKSlyZXR1
 cm4gSC50NihhKQpyZXR1cm4gSC5WVShKLmlhKGEpKX0sCnQ2OmZ1bmN0aW9uKGEpe3ZhciBzPWFbdi5h
-cnJheVJ0aV0scj10LngKaWYocz09bnVsbClyZXR1cm4gcgppZihzLmNvbnN0cnVjdG9yIT09ci5jb25z
+cnJheVJ0aV0scj10LmIKaWYocz09bnVsbClyZXR1cm4gcgppZihzLmNvbnN0cnVjdG9yIT09ci5jb25z
 dHJ1Y3RvcilyZXR1cm4gcgpyZXR1cm4gc30sCkxoOmZ1bmN0aW9uKGEpe3ZhciBzPWEuJHRpCnJldHVy
 biBzIT1udWxsP3M6SC5WVShhKX0sClZVOmZ1bmN0aW9uKGEpe3ZhciBzPWEuY29uc3RydWN0b3Iscj1z
 LiRjY2FjaGUKaWYociE9bnVsbClyZXR1cm4gcgpyZXR1cm4gSC5yOShhLHMpfSwKcjk6ZnVuY3Rpb24o
@@ -8380,11 +8380,11 @@
 cmV0dXJuIHN9aWYocD09PTgpe2lmKEguV2UoYSxiLGMsZC56LGUpKXJldHVybiEwCnJldHVybiBILldl
 KGEsYixjLEgueFooYSxkKSxlKX1pZihwPT09Nyl7cz1ILldlKGEsYixjLGQueixlKQpyZXR1cm4gc31p
 ZihxKXJldHVybiExCnM9ciE9PTExCmlmKCghc3x8cj09PTEyKSYmZD09PXQuWSlyZXR1cm4hMAppZihw
-PT09MTIpe2lmKGI9PT10LkQpcmV0dXJuITAKaWYociE9PTEyKXJldHVybiExCm89Yi5RCm49ZC5RCm09
+PT09MTIpe2lmKGI9PT10LngpcmV0dXJuITAKaWYociE9PTEyKXJldHVybiExCm89Yi5RCm49ZC5RCm09
 by5sZW5ndGgKaWYobSE9PW4ubGVuZ3RoKXJldHVybiExCmM9Yz09bnVsbD9vOm8uY29uY2F0KGMpCmU9
 ZT09bnVsbD9uOm4uY29uY2F0KGUpCmZvcihsPTA7bDxtOysrbCl7az1vW2xdCmo9bltsXQppZighSC5X
 ZShhLGssYyxqLGUpfHwhSC5XZShhLGosZSxrLGMpKXJldHVybiExfXJldHVybiBILmJPKGEsYi56LGMs
-ZC56LGUpfWlmKHA9PT0xMSl7aWYoYj09PXQuRClyZXR1cm4hMAppZihzKXJldHVybiExCnJldHVybiBI
+ZC56LGUpfWlmKHA9PT0xMSl7aWYoYj09PXQueClyZXR1cm4hMAppZihzKXJldHVybiExCnJldHVybiBI
 LmJPKGEsYixjLGQsZSl9aWYocj09PTkpe2lmKHAhPT05KXJldHVybiExCnJldHVybiBILnBHKGEsYixj
 LGQsZSl9cmV0dXJuITF9LApiTzpmdW5jdGlvbihhMixhMyxhNCxhNSxhNil7dmFyIHMscixxLHAsbyxu
 LG0sbCxrLGosaSxoLGcsZixlLGQsYyxiLGEsYTAsYTEKaWYoIUguV2UoYTIsYTMueixhNCxhNS56LGE2
@@ -8524,3262 +8524,3266 @@
 UTpmdW5jdGlvbihhLGIpe1AuSmUoYSxiKX0sCnlDOmZ1bmN0aW9uKGEsYil7Yi5hTSgwLGEpfSwKZjM6
 ZnVuY3Rpb24oYSxiKXtiLncwKEguUnUoYSksSC50cyhhKSl9LApKZTpmdW5jdGlvbihhLGIpe3ZhciBz
 LHIscT1uZXcgUC5XTShiKSxwPW5ldyBQLlNYKGIpCmlmKGEgaW5zdGFuY2VvZiBQLnZzKWEuUWQocSxw
-LHQueikKZWxzZXtzPXQuegppZih0LmQuYihhKSlhLlNxKHEscCxzKQplbHNle3I9bmV3IFAudnMoJC5Y
+LHQueikKZWxzZXtzPXQuegppZih0LmUuYihhKSlhLlNxKHEscCxzKQplbHNle3I9bmV3IFAudnMoJC5Y
 Myx0LmMpCnIuYT00CnIuYz1hCnIuUWQocSxwLHMpfX19LApsejpmdW5jdGlvbihhKXt2YXIgcz1mdW5j
 dGlvbihiLGMpe3JldHVybiBmdW5jdGlvbihkLGUpe3doaWxlKHRydWUpdHJ5e2IoZCxlKQpicmVha31j
 YXRjaChyKXtlPXIKZD1jfX19KGEsMSkKcmV0dXJuICQuWDMuTGoobmV3IFAuR3MocyksdC5ILHQuUyx0
 LnopfSwKSUc6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLkZ5KGEsMSl9LApUaDpmdW5jdGlvbigpe3Jl
 dHVybiBDLndRfSwKWW06ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLkZ5KGEsMyl9LApsMDpmdW5jdGlv
-bihhLGIpe3JldHVybiBuZXcgUC5xNChhLGIuQygicTQ8MD4iKSl9LAprMzpmdW5jdGlvbihhLGIpe3Zh
-ciBzLHIscQpiLmE9MQp0cnl7YS5TcShuZXcgUC5wVihiKSxuZXcgUC5VNyhiKSx0LlApfWNhdGNoKHEp
-e3M9SC5SdShxKQpyPUgudHMocSkKUC5yYihuZXcgUC52cihiLHMscikpfX0sCkE5OmZ1bmN0aW9uKGEs
-Yil7dmFyIHMscixxCmZvcihzPXQuYztyPWEuYSxyPT09MjspYT1zLmEoYS5jKQppZihyPj00KXtxPWIu
-YWgoKQpiLmE9YS5hCmIuYz1hLmMKUC5IWihiLHEpfWVsc2V7cT10LkYuYShiLmMpCmIuYT0yCmIuYz1h
-CmEualEocSl9fSwKSFo6ZnVuY3Rpb24oYTAsYTEpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxn
-LGYsZSxkLGM9bnVsbCxiPXt9LGE9Yi5hPWEwCmZvcihzPXQubixyPXQuRixxPXQuZDshMDspe3A9e30K
-bz1hLmE9PT04CmlmKGExPT1udWxsKXtpZihvKXtuPXMuYShhLmMpClAuTDIoYyxjLGEuYixuLmEsbi5i
-KX1yZXR1cm59cC5hPWExCm09YTEuYQpmb3IoYT1hMTttIT1udWxsO2E9bSxtPWwpe2EuYT1udWxsClAu
-SFooYi5hLGEpCnAuYT1tCmw9bS5hfWs9Yi5hCmo9ay5jCnAuYj1vCnAuYz1qCmk9IW8KaWYoaSl7aD1h
-LmMKaD0oaCYxKSE9PTB8fChoJjE1KT09PTh9ZWxzZSBoPSEwCmlmKGgpe2c9YS5iLmIKaWYobyl7aD1r
-LmI9PT1nCmg9IShofHxoKX1lbHNlIGg9ITEKaWYoaCl7cy5hKGopClAuTDIoYyxjLGsuYixqLmEsai5i
-KQpyZXR1cm59Zj0kLlgzCmlmKGYhPT1nKSQuWDM9ZwplbHNlIGY9YwphPWEuYwppZigoYSYxNSk9PT04
-KW5ldyBQLlJUKHAsYixvKS4kMCgpCmVsc2UgaWYoaSl7aWYoKGEmMSkhPT0wKW5ldyBQLnJxKHAsaiku
-JDAoKX1lbHNlIGlmKChhJjIpIT09MCluZXcgUC5SVyhiLHApLiQwKCkKaWYoZiE9bnVsbCkkLlgzPWYK
-YT1wLmMKaWYocS5iKGEpKXtlPXAuYS5iCmlmKGEuYT49NCl7ZD1yLmEoZS5jKQplLmM9bnVsbAphMT1l
-Lk44KGQpCmUuYT1hLmEKZS5jPWEuYwpiLmE9YQpjb250aW51ZX1lbHNlIFAuQTkoYSxlKQpyZXR1cm59
-fWU9cC5hLmIKZD1yLmEoZS5jKQplLmM9bnVsbAphMT1lLk44KGQpCmE9cC5iCms9cC5jCmlmKCFhKXtl
-LiR0aS5jLmEoaykKZS5hPTQKZS5jPWt9ZWxzZXtzLmEoaykKZS5hPTgKZS5jPWt9Yi5hPWUKYT1lfX0s
-ClZIOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYodC5hZy5iKGEpKXJldHVybiBiLkxqKGEsdC56LHQuSyx0
-LmwpCnM9dC5iSQppZihzLmIoYSkpcmV0dXJuIHMuYShhKQp0aHJvdyBILmIoUC5MMyhhLCJvbkVycm9y
-IiwiRXJyb3IgaGFuZGxlciBtdXN0IGFjY2VwdCBvbmUgT2JqZWN0IG9yIG9uZSBPYmplY3QgYW5kIGEg
-U3RhY2tUcmFjZSBhcyBhcmd1bWVudHMsIGFuZCByZXR1cm4gYSBhIHZhbGlkIHJlc3VsdCIpKX0sCnB1
-OmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz0kLlM2O3MhPW51bGw7cz0kLlM2KXskLm1nPW51bGwKcj1z
-LmIKJC5TNj1yCmlmKHI9PW51bGwpJC5rOD1udWxsCnMuYS4kMCgpfX0sCmVOOmZ1bmN0aW9uKCl7JC5V
-RD0hMAp0cnl7UC5wdSgpfWZpbmFsbHl7JC5tZz1udWxsCiQuVUQ9ITEKaWYoJC5TNiE9bnVsbCkkLnV0
-KCkuJDEoUC5VSSgpKX19LAplVzpmdW5jdGlvbihhKXt2YXIgcz1uZXcgUC5PTShhKSxyPSQuazgKaWYo
-cj09bnVsbCl7JC5TNj0kLms4PXMKaWYoISQuVUQpJC51dCgpLiQxKFAuVUkoKSl9ZWxzZSAkLms4PXIu
-Yj1zfSwKclI6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9JC5TNgppZihwPT1udWxsKXtQLmVXKGEpCiQu
-bWc9JC5rOApyZXR1cm59cz1uZXcgUC5PTShhKQpyPSQubWcKaWYocj09bnVsbCl7cy5iPXAKJC5TNj0k
-Lm1nPXN9ZWxzZXtxPXIuYgpzLmI9cQokLm1nPXIuYj1zCmlmKHE9PW51bGwpJC5rOD1zfX0sCnJiOmZ1
-bmN0aW9uKGEpe3ZhciBzPW51bGwscj0kLlgzCmlmKEMuTlU9PT1yKXtQLlRrKHMscyxDLk5VLGEpCnJl
-dHVybn1QLlRrKHMscyxyLHQuTS5hKHIudDgoYSkpKX0sClF3OmZ1bmN0aW9uKGEsYil7SC5jYihhLCJz
-dHJlYW0iLHQuSykKcmV0dXJuIG5ldyBQLnhJKGIuQygieEk8MD4iKSl9LApUbDpmdW5jdGlvbihhLGIp
-e3ZhciBzPUguY2IoYSwiZXJyb3IiLHQuSykKcmV0dXJuIG5ldyBQLkN3KHMsYj09bnVsbD9QLnYwKGEp
-OmIpfSwKdjA6ZnVuY3Rpb24oYSl7dmFyIHMKaWYodC5yLmIoYSkpe3M9YS5nSUkoKQppZihzIT1udWxs
-KXJldHVybiBzfXJldHVybiBDLnBkfSwKTDI6ZnVuY3Rpb24oYSxiLGMsZCxlKXtQLnJSKG5ldyBQLnBL
-KGQsZSkpfSwKVDg6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJu
-IGQuJDAoKQokLlgzPWMKcz1yCnRyeXtyPWQuJDAoKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LAp5
-djpmdW5jdGlvbihhLGIsYyxkLGUsZixnKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDEo
-ZSkKJC5YMz1jCnM9cgp0cnl7cj1kLiQxKGUpCnJldHVybiByfWZpbmFsbHl7JC5YMz1zfX0sClF4OmZ1
-bmN0aW9uKGEsYixjLGQsZSxmLGcsaCxpKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDIo
-ZSxmKQokLlgzPWMKcz1yCnRyeXtyPWQuJDIoZSxmKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LApU
-azpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcwp0Lk0uYShkKQpzPUMuTlUhPT1jCmlmKHMpZD0hKCFzfHwh
-MSk/Yy50OChkKTpjLlJUKGQsdC5IKQpQLmVXKGQpfSwKdGg6ZnVuY3Rpb24gdGgoYSl7dGhpcy5hPWF9
-LApoYTpmdW5jdGlvbiBoYShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApWczpmdW5j
-dGlvbiBWcyhhKXt0aGlzLmE9YX0sCkZ0OmZ1bmN0aW9uIEZ0KGEpe3RoaXMuYT1hfSwKVzM6ZnVuY3Rp
-b24gVzMoKXt9LAp5SDpmdW5jdGlvbiB5SChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKaWg6ZnVuY3Rp
-b24gaWgoYSxiKXt0aGlzLmE9YQp0aGlzLmI9ITEKdGhpcy4kdGk9Yn0sCldNOmZ1bmN0aW9uIFdNKGEp
-e3RoaXMuYT1hfSwKU1g6ZnVuY3Rpb24gU1goYSl7dGhpcy5hPWF9LApHczpmdW5jdGlvbiBHcyhhKXt0
-aGlzLmE9YX0sCkZ5OmZ1bmN0aW9uIEZ5KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApHVjpmdW5jdGlv
-biBHVihhLGIpe3ZhciBfPXRoaXMKXy5hPWEKXy5kPV8uYz1fLmI9bnVsbApfLiR0aT1ifSwKcTQ6ZnVu
-Y3Rpb24gcTQoYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKUGY6ZnVuY3Rpb24gUGYoKXt9LApaZjpm
-dW5jdGlvbiBaZihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApGZTpmdW5jdGlvbiBGZShhLGIsYyxk
-LGUpe3ZhciBfPXRoaXMKXy5hPW51bGwKXy5iPWEKXy5jPWIKXy5kPWMKXy5lPWQKXy4kdGk9ZX0sCnZz
-OmZ1bmN0aW9uIHZzKGEsYil7dmFyIF89dGhpcwpfLmE9MApfLmI9YQpfLmM9bnVsbApfLiR0aT1ifSwK
-ZGE6ZnVuY3Rpb24gZGEoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCm9ROmZ1bmN0aW9uIG9RKGEsYil7
-dGhpcy5hPWEKdGhpcy5iPWJ9LApwVjpmdW5jdGlvbiBwVihhKXt0aGlzLmE9YX0sClU3OmZ1bmN0aW9u
-IFU3KGEpe3RoaXMuYT1hfSwKdnI6ZnVuY3Rpb24gdnIoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRo
-aXMuYz1jfSwKcnQ6ZnVuY3Rpb24gcnQoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCktGOmZ1bmN0aW9u
-IEtGKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApaTDpmdW5jdGlvbiBaTChhLGIsYyl7dGhpcy5hPWEK
-dGhpcy5iPWIKdGhpcy5jPWN9LApSVDpmdW5jdGlvbiBSVChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIK
-dGhpcy5jPWN9LApqWjpmdW5jdGlvbiBqWihhKXt0aGlzLmE9YX0sCnJxOmZ1bmN0aW9uIHJxKGEsYil7
-dGhpcy5hPWEKdGhpcy5iPWJ9LApSVzpmdW5jdGlvbiBSVyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwK
-T006ZnVuY3Rpb24gT00oYSl7dGhpcy5hPWEKdGhpcy5iPW51bGx9LApxaDpmdW5jdGlvbiBxaCgpe30s
-CkI1OmZ1bmN0aW9uIEI1KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LAp1TzpmdW5jdGlvbiB1TyhhLGIp
-e3RoaXMuYT1hCnRoaXMuYj1ifSwKTU86ZnVuY3Rpb24gTU8oKXt9LAprVDpmdW5jdGlvbiBrVCgpe30s
-CnhJOmZ1bmN0aW9uIHhJKGEpe3RoaXMuJHRpPWF9LApDdzpmdW5jdGlvbiBDdyhhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKbTA6ZnVuY3Rpb24gbTAoKXt9LApwSzpmdW5jdGlvbiBwSyhhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKSmk6ZnVuY3Rpb24gSmkoKXt9LApoajpmdW5jdGlvbiBoaihhLGIsYyl7dGhpcy5h
-PWEKdGhpcy5iPWIKdGhpcy5jPWN9LApWcDpmdW5jdGlvbiBWcChhLGIpe3RoaXMuYT1hCnRoaXMuYj1i
-fSwKT1I6ZnVuY3Rpb24gT1IoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKRUY6ZnVu
-Y3Rpb24oYSxiLGMpe3JldHVybiBiLkMoIkA8MD4iKS5LcShjKS5DKCJGbzwxLDI+IikuYShILkI3KGEs
-bmV3IEguTjUoYi5DKCJAPDA+IikuS3EoYykuQygiTjU8MSwyPiIpKSkpfSwKRmw6ZnVuY3Rpb24oYSxi
-KXtyZXR1cm4gbmV3IEguTjUoYS5DKCJAPDA+IikuS3EoYikuQygiTjU8MSwyPiIpKX0sCkxzOmZ1bmN0
-aW9uKGEpe3JldHVybiBuZXcgUC5iNihhLkMoImI2PDA+IikpfSwKVDI6ZnVuY3Rpb24oKXt2YXIgcz1P
-YmplY3QuY3JlYXRlKG51bGwpCnNbIjxub24taWRlbnRpZmllci1rZXk+Il09cwpkZWxldGUgc1siPG5v
-bi1pZGVudGlmaWVyLWtleT4iXQpyZXR1cm4gc30sCnJqOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1uZXcg
-UC5sbShhLGIsYy5DKCJsbTwwPiIpKQpzLmM9YS5lCnJldHVybiBzfSwKRVA6ZnVuY3Rpb24oYSxiLGMp
-e3ZhciBzLHIKaWYoUC5oQihhKSl7aWYoYj09PSIoIiYmYz09PSIpIilyZXR1cm4iKC4uLikiCnJldHVy
-biBiKyIuLi4iK2N9cz1ILlZNKFtdLHQucykKQy5ObS5pKCQueGcsYSkKdHJ5e1AuVnIoYSxzKX1maW5h
-bGx5e2lmKDA+PSQueGcubGVuZ3RoKXJldHVybiBILk9IKCQueGcsLTEpCiQueGcucG9wKCl9cj1QLnZn
-KGIsdC51LmEocyksIiwgIikrYwpyZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn0sCldFOmZ1bmN0
-aW9uKGEsYixjKXt2YXIgcyxyCmlmKFAuaEIoYSkpcmV0dXJuIGIrIi4uLiIrYwpzPW5ldyBQLlJuKGIp
-CkMuTm0uaSgkLnhnLGEpCnRyeXtyPXMKci5hPVAudmcoci5hLGEsIiwgIil9ZmluYWxseXtpZigwPj0k
-LnhnLmxlbmd0aClyZXR1cm4gSC5PSCgkLnhnLC0xKQokLnhnLnBvcCgpfXMuYSs9YwpyPXMuYQpyZXR1
-cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn0sCmhCOmZ1bmN0aW9uKGEpe3ZhciBzLHIKZm9yKHM9JC54
-Zy5sZW5ndGgscj0wO3I8czsrK3IpaWYoYT09PSQueGdbcl0pcmV0dXJuITAKcmV0dXJuITF9LApWcjpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGw9YS5nbShhKSxrPTAsaj0wCndoaWxlKCEwKXtp
-ZighKGs8ODB8fGo8MykpYnJlYWsKaWYoIWwuRigpKXJldHVybgpzPUguRWoobC5nbCgpKQpDLk5tLmko
-YixzKQprKz1zLmxlbmd0aCsyOysran1pZighbC5GKCkpe2lmKGo8PTUpcmV0dXJuCmlmKDA+PWIubGVu
-Z3RoKXJldHVybiBILk9IKGIsLTEpCnI9Yi5wb3AoKQppZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChi
-LC0xKQpxPWIucG9wKCl9ZWxzZXtwPWwuZ2woKTsrK2oKaWYoIWwuRigpKXtpZihqPD00KXtDLk5tLmko
-YixILkVqKHApKQpyZXR1cm59cj1ILkVqKHApCmlmKDA+PWIubGVuZ3RoKXJldHVybiBILk9IKGIsLTEp
-CnE9Yi5wb3AoKQprKz1yLmxlbmd0aCsyfWVsc2V7bz1sLmdsKCk7KytqCmZvcig7bC5GKCk7cD1vLG89
-bil7bj1sLmdsKCk7KytqCmlmKGo+MTAwKXt3aGlsZSghMCl7aWYoIShrPjc1JiZqPjMpKWJyZWFrCmlm
-KDA+PWIubGVuZ3RoKXJldHVybiBILk9IKGIsLTEpCmstPWIucG9wKCkubGVuZ3RoKzI7LS1qfUMuTm0u
-aShiLCIuLi4iKQpyZXR1cm59fXE9SC5FaihwKQpyPUguRWoobykKays9ci5sZW5ndGgrcS5sZW5ndGgr
-NH19aWYoaj5iLmxlbmd0aCsyKXtrKz01Cm09Ii4uLiJ9ZWxzZSBtPW51bGwKd2hpbGUoITApe2lmKCEo
-az44MCYmYi5sZW5ndGg+MykpYnJlYWsKaWYoMD49Yi5sZW5ndGgpcmV0dXJuIEguT0goYiwtMSkKay09
-Yi5wb3AoKS5sZW5ndGgrMgppZihtPT1udWxsKXtrKz01Cm09Ii4uLiJ9fWlmKG0hPW51bGwpQy5ObS5p
-KGIsbSkKQy5ObS5pKGIscSkKQy5ObS5pKGIscil9LAp0TTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1Q
-LkxzKGIpCmZvcihzPWEubGVuZ3RoLHI9MDtyPGEubGVuZ3RoO2EubGVuZ3RoPT09c3x8KDAsSC5sayko
-YSksKytyKXEuaSgwLGIuYShhW3JdKSkKcmV0dXJuIHF9LApuTzpmdW5jdGlvbihhKXt2YXIgcyxyPXt9
-CmlmKFAuaEIoYSkpcmV0dXJuInsuLi59IgpzPW5ldyBQLlJuKCIiKQp0cnl7Qy5ObS5pKCQueGcsYSkK
-cy5hKz0ieyIKci5hPSEwCmEuSygwLG5ldyBQLnJhKHIscykpCnMuYSs9In0ifWZpbmFsbHl7aWYoMD49
-JC54Zy5sZW5ndGgpcmV0dXJuIEguT0goJC54ZywtMSkKJC54Zy5wb3AoKX1yPXMuYQpyZXR1cm4gci5j
-aGFyQ29kZUF0KDApPT0wP3I6cn0sCmI2OmZ1bmN0aW9uIGI2KGEpe3ZhciBfPXRoaXMKXy5hPTAKXy5m
-PV8uZT1fLmQ9Xy5jPV8uYj1udWxsCl8ucj0wCl8uJHRpPWF9LApibjpmdW5jdGlvbiBibihhKXt0aGlz
-LmE9YQp0aGlzLmM9dGhpcy5iPW51bGx9LApsbTpmdW5jdGlvbiBsbShhLGIsYyl7dmFyIF89dGhpcwpf
-LmE9YQpfLmI9YgpfLmQ9Xy5jPW51bGwKXy4kdGk9Y30sCm1XOmZ1bmN0aW9uIG1XKCl7fSwKdXk6ZnVu
-Y3Rpb24gdXkoKXt9LApsRDpmdW5jdGlvbiBsRCgpe30sCmlsOmZ1bmN0aW9uIGlsKCl7fSwKcmE6ZnVu
-Y3Rpb24gcmEoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCllrOmZ1bmN0aW9uIFlrKCl7fSwKeVE6ZnVu
-Y3Rpb24geVEoYSl7dGhpcy5hPWF9LApLUDpmdW5jdGlvbiBLUCgpe30sClBuOmZ1bmN0aW9uIFBuKCl7
-fSwKR2o6ZnVuY3Rpb24gR2ooYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKbGY6ZnVuY3Rpb24gbGYo
-KXt9LApWajpmdW5jdGlvbiBWaigpe30sClh2OmZ1bmN0aW9uIFh2KCl7fSwKblk6ZnVuY3Rpb24gblko
-KXt9LApXWTpmdW5jdGlvbiBXWSgpe30sClJVOmZ1bmN0aW9uIFJVKCl7fSwKcFI6ZnVuY3Rpb24gcFIo
-KXt9LApCUzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwCmlmKHR5cGVvZiBhIT0ic3RyaW5nIil0aHJv
-dyBILmIoSC50TChhKSkKcz1udWxsCnRyeXtzPUpTT04ucGFyc2UoYSl9Y2F0Y2gocSl7cj1ILlJ1KHEp
-CnA9UC5ycihTdHJpbmcociksbnVsbCxudWxsKQp0aHJvdyBILmIocCl9cD1QLlFlKHMpCnJldHVybiBw
-fSwKUWU6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoYT09bnVsbClyZXR1cm4gbnVsbAppZih0eXBlb2YgYSE9
-Im9iamVjdCIpcmV0dXJuIGEKaWYoT2JqZWN0LmdldFByb3RvdHlwZU9mKGEpIT09QXJyYXkucHJvdG90
-eXBlKXJldHVybiBuZXcgUC51dyhhLE9iamVjdC5jcmVhdGUobnVsbCkpCmZvcihzPTA7czxhLmxlbmd0
-aDsrK3MpYVtzXT1QLlFlKGFbc10pCnJldHVybiBhfSwKa3k6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMs
-cgppZihiIGluc3RhbmNlb2YgVWludDhBcnJheSl7cz1iCmQ9cy5sZW5ndGgKaWYoZC1jPDE1KXJldHVy
-biBudWxsCnI9UC5DRyhhLHMsYyxkKQppZihyIT1udWxsJiZhKWlmKHIuaW5kZXhPZigiXHVmZmZkIik+
-PTApcmV0dXJuIG51bGwKcmV0dXJuIHJ9cmV0dXJuIG51bGx9LApDRzpmdW5jdGlvbihhLGIsYyxkKXt2
-YXIgcz1hPyQuSEcoKTokLnJmKCkKaWYocz09bnVsbClyZXR1cm4gbnVsbAppZigwPT09YyYmZD09PWIu
-bGVuZ3RoKXJldHVybiBQLlJiKHMsYikKcmV0dXJuIFAuUmIocyxiLnN1YmFycmF5KGMsUC5qQihjLGQs
-Yi5sZW5ndGgpKSl9LApSYjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKdHJ5e3M9YS5kZWNvZGUoYikKcmV0
-dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1yZXR1cm4gbnVsbH0sCnhNOmZ1bmN0aW9uKGEsYixjLGQsZSxm
-KXtpZihDLmpuLnpZKGYsNCkhPT0wKXRocm93IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBwYWRkaW5n
-LCBwYWRkZWQgbGVuZ3RoIG11c3QgYmUgbXVsdGlwbGUgb2YgZm91ciwgaXMgIitmLGEsYykpCmlmKGQr
-ZSE9PWYpdGhyb3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IHBhZGRpbmcsICc9JyBub3QgYXQgdGhl
-IGVuZCIsYSxiKSkKaWYoZT4yKXRocm93IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBwYWRkaW5nLCBt
-b3JlIHRoYW4gdHdvICc9JyBjaGFyYWN0ZXJzIixhLGIpKX0sCkd5OmZ1bmN0aW9uKGEsYixjKXtyZXR1
-cm4gbmV3IFAuVWQoYSxiKX0sCk5DOmZ1bmN0aW9uKGEpe3JldHVybiBhLkx0KCl9LApVZzpmdW5jdGlv
-bihhLGIpe3JldHVybiBuZXcgUC50dShhLFtdLFAuQ3koKSl9LAp1WDpmdW5jdGlvbihhLGIsYyl7dmFy
-IHMscj1uZXcgUC5SbigiIikscT1QLlVnKHIsYikKcS5pVShhKQpzPXIuYQpyZXR1cm4gcy5jaGFyQ29k
-ZUF0KDApPT0wP3M6c30sCmo0OmZ1bmN0aW9uKGEpe3N3aXRjaChhKXtjYXNlIDY1OnJldHVybiJNaXNz
-aW5nIGV4dGVuc2lvbiBieXRlIgpjYXNlIDY3OnJldHVybiJVbmV4cGVjdGVkIGV4dGVuc2lvbiBieXRl
-IgpjYXNlIDY5OnJldHVybiJJbnZhbGlkIFVURi04IGJ5dGUiCmNhc2UgNzE6cmV0dXJuIk92ZXJsb25n
-IGVuY29kaW5nIgpjYXNlIDczOnJldHVybiJPdXQgb2YgdW5pY29kZSByYW5nZSIKY2FzZSA3NTpyZXR1
-cm4iRW5jb2RlZCBzdXJyb2dhdGUiCmNhc2UgNzc6cmV0dXJuIlVuZmluaXNoZWQgVVRGLTggb2N0ZXQg
-c2VxdWVuY2UiCmRlZmF1bHQ6cmV0dXJuIiJ9fSwKank6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxw
-PWMtYixvPW5ldyBVaW50OEFycmF5KHApCmZvcihzPUouVTYoYSkscj0wO3I8cDsrK3Ipe3E9cy5xKGEs
-YityKQppZih0eXBlb2YgcSE9PSJudW1iZXIiKXJldHVybiBxLnpNKCkKaWYoKHEmNDI5NDk2NzA0MCk+
-Pj4wIT09MClxPTI1NQppZihyPj1wKXJldHVybiBILk9IKG8scikKb1tyXT1xfXJldHVybiBvfSwKdXc6
-ZnVuY3Rpb24gdXcoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9bnVsbH0sCmk4OmZ1bmN0aW9u
-IGk4KGEpe3RoaXMuYT1hfSwKcGc6ZnVuY3Rpb24gcGcoKXt9LApjMjpmdW5jdGlvbiBjMigpe30sCkNW
-OmZ1bmN0aW9uIENWKCl7fSwKVTg6ZnVuY3Rpb24gVTgoKXt9LApVazpmdW5jdGlvbiBVaygpe30sCndJ
-OmZ1bmN0aW9uIHdJKCl7fSwKWmk6ZnVuY3Rpb24gWmkoKXt9LApVZDpmdW5jdGlvbiBVZChhLGIpe3Ro
-aXMuYT1hCnRoaXMuYj1ifSwKSzg6ZnVuY3Rpb24gSzgoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCmJ5
-OmZ1bmN0aW9uIGJ5KCl7fSwKb2o6ZnVuY3Rpb24gb2ooYSl7dGhpcy5iPWF9LApNeDpmdW5jdGlvbiBN
-eChhKXt0aGlzLmE9YX0sClNoOmZ1bmN0aW9uIFNoKCl7fSwKdGk6ZnVuY3Rpb24gdGkoYSxiKXt0aGlz
-LmE9YQp0aGlzLmI9Yn0sCnR1OmZ1bmN0aW9uIHR1KGEsYixjKXt0aGlzLmM9YQp0aGlzLmE9Ygp0aGlz
-LmI9Y30sCnU1OmZ1bmN0aW9uIHU1KCl7fSwKRTM6ZnVuY3Rpb24gRTMoKXt9LApSdzpmdW5jdGlvbiBS
-dyhhKXt0aGlzLmI9MAp0aGlzLmM9YX0sCkdZOmZ1bmN0aW9uIEdZKGEpe3RoaXMuYT1hfSwKYno6ZnVu
-Y3Rpb24gYnooYSl7dGhpcy5hPWEKdGhpcy5iPTE2CnRoaXMuYz0wfSwKUUE6ZnVuY3Rpb24oYSxiKXt2
-YXIgcz1ILkhwKGEsYikKaWYocyE9bnVsbClyZXR1cm4gcwp0aHJvdyBILmIoUC5ycihhLG51bGwsbnVs
-bCkpfSwKb3M6ZnVuY3Rpb24oYSl7aWYoYSBpbnN0YW5jZW9mIEguVHApcmV0dXJuIGEudygwKQpyZXR1
-cm4iSW5zdGFuY2Ugb2YgJyIrSC5FaihILk0oYSkpKyInIn0sCk84OmZ1bmN0aW9uKGEsYixjLGQpe3Zh
-ciBzLHI9Yz9KLktoKGEsZCk6Si5RaShhLGQpCmlmKGEhPT0wJiZiIT1udWxsKWZvcihzPTA7czxyLmxl
-bmd0aDsrK3MpcltzXT1iCnJldHVybiByfSwKQ0g6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9SC5WTShb
-XSxjLkMoImpkPDA+IikpCmZvcihzPUouSVQoYSk7cy5GKCk7KUMuTm0uaShyLGMuYShzLmdsKCkpKQpp
-ZihiKXJldHVybiByCnJldHVybiBKLkVwKHIsYyl9LApZMTpmdW5jdGlvbihhLGIsYyl7dmFyIHMKaWYo
-YilyZXR1cm4gUC5ldihhLGMpCnM9Si5FcChQLmV2KGEsYyksYykKcmV0dXJuIHN9LApldjpmdW5jdGlv
-bihhLGIpe3ZhciBzLHIKaWYoQXJyYXkuaXNBcnJheShhKSlyZXR1cm4gSC5WTShhLnNsaWNlKDApLGIu
-QygiamQ8MD4iKSkKcz1ILlZNKFtdLGIuQygiamQ8MD4iKSkKZm9yKHI9Si5JVChhKTtyLkYoKTspQy5O
-bS5pKHMsci5nbCgpKQpyZXR1cm4gc30sCkFGOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouekMoUC5DSChh
-LCExLGIpKX0sCkhNOmZ1bmN0aW9uKGEsYixjKXtpZih0LmJtLmIoYSkpcmV0dXJuIEguZncoYSxiLFAu
-akIoYixjLGEubGVuZ3RoKSkKcmV0dXJuIFAuYncoYSxiLGMpfSwKT286ZnVuY3Rpb24oYSl7cmV0dXJu
-IEguTHcoYSl9LApidzpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbz1udWxsCmlmKGI8MCl0aHJv
-dyBILmIoUC5URShiLDAsYS5sZW5ndGgsbyxvKSkKcz1jPT1udWxsCmlmKCFzJiZjPGIpdGhyb3cgSC5i
-KFAuVEUoYyxiLGEubGVuZ3RoLG8sbykpCnI9bmV3IEguYTcoYSxhLmxlbmd0aCxILnooYSkuQygiYTc8
-bEQuRT4iKSkKZm9yKHE9MDtxPGI7KytxKWlmKCFyLkYoKSl0aHJvdyBILmIoUC5URShiLDAscSxvLG8p
-KQpwPVtdCmlmKHMpZm9yKDtyLkYoKTspcC5wdXNoKHIuZCkKZWxzZSBmb3IocT1iO3E8YzsrK3Epe2lm
-KCFyLkYoKSl0aHJvdyBILmIoUC5URShjLGIscSxvLG8pKQpwLnB1c2goci5kKX1yZXR1cm4gSC5lVChw
-KX0sCm51OmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5WUihhLEgudjQoYSwhMSwhMCwhMSwhMSwhMSkp
-fSwKdmc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUouSVQoYikKaWYoIXMuRigpKXJldHVybiBhCmlmKGMu
-bGVuZ3RoPT09MCl7ZG8gYSs9SC5FaihzLmdsKCkpCndoaWxlKHMuRigpKX1lbHNle2ErPUguRWoocy5n
-bCgpKQpmb3IoO3MuRigpOylhPWErYytILkVqKHMuZ2woKSl9cmV0dXJuIGF9LApscjpmdW5jdGlvbihh
-LGIsYyxkKXtyZXR1cm4gbmV3IFAubXAoYSxiLGMsZCl9LAp1bzpmdW5jdGlvbigpe3ZhciBzPUguTTAo
-KQppZihzIT1udWxsKXJldHVybiBQLmhLKHMpCnRocm93IEguYihQLkw0KCInVXJpLmJhc2UnIGlzIG5v
-dCBzdXBwb3J0ZWQiKSl9LAplUDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbT0iMDEy
-MzQ1Njc4OUFCQ0RFRiIKaWYoYz09PUMueE0pe3M9JC56NCgpLmIKaWYodHlwZW9mIGIhPSJzdHJpbmci
-KUgudihILnRMKGIpKQpzPXMudGVzdChiKX1lbHNlIHM9ITEKaWYocylyZXR1cm4gYgpILkxoKGMpLkMo
-IlVrLlMiKS5hKGIpCnI9Yy5nWkUoKS5XSihiKQpmb3Iocz1yLmxlbmd0aCxxPTAscD0iIjtxPHM7Kytx
-KXtvPXJbcV0KaWYobzwxMjgpe249bz4+PjQKaWYobj49OClyZXR1cm4gSC5PSChhLG4pCm49KGFbbl0m
-MTw8KG8mMTUpKSE9PTB9ZWxzZSBuPSExCmlmKG4pcCs9SC5MdyhvKQplbHNlIHA9ZCYmbz09PTMyP3Ar
-IisiOnArIiUiK21bbz4+PjQmMTVdK21bbyYxNV19cmV0dXJuIHAuY2hhckNvZGVBdCgwKT09MD9wOnB9
-LApHcTpmdW5jdGlvbihhKXt2YXIgcz1NYXRoLmFicyhhKSxyPWE8MD8iLSI6IiIKaWYocz49MTAwMCly
-ZXR1cm4iIithCmlmKHM+PTEwMClyZXR1cm4gcisiMCIrcwppZihzPj0xMClyZXR1cm4gcisiMDAiK3MK
-cmV0dXJuIHIrIjAwMCIrc30sClZ4OmZ1bmN0aW9uKGEpe2lmKGE+PTEwMClyZXR1cm4iIithCmlmKGE+
-PTEwKXJldHVybiIwIithCnJldHVybiIwMCIrYX0sCmgwOmZ1bmN0aW9uKGEpe2lmKGE+PTEwKXJldHVy
-biIiK2EKcmV0dXJuIjAiK2F9LApwOmZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVtYmVyInx8SC5s
-KGEpfHxudWxsPT1hKXJldHVybiBKLmooYSkKaWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBKU09O
-LnN0cmluZ2lmeShhKQpyZXR1cm4gUC5vcyhhKX0sCmhWOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5D
-NihhKX0sCnhZOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC51KCExLG51bGwsbnVsbCxhKX0sCkwzOmZ1
-bmN0aW9uKGEsYixjKXtyZXR1cm4gbmV3IFAudSghMCxhLGIsYyl9LApNUjpmdW5jdGlvbihhLGIsYyl7
-cmV0dXJuIGF9LApPNzpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC5iSihudWxsLG51bGwsITAsYSxi
-LCJWYWx1ZSBub3QgaW4gcmFuZ2UiKX0sClRFOmZ1bmN0aW9uKGEsYixjLGQsZSl7cmV0dXJuIG5ldyBQ
-LmJKKGIsYywhMCxhLGQsIkludmFsaWQgdmFsdWUiKX0sCndBOmZ1bmN0aW9uKGEsYixjLGQpe2lmKGE8
-Ynx8YT5jKXRocm93IEguYihQLlRFKGEsYixjLGQsbnVsbCkpCnJldHVybiBhfSwKakI6ZnVuY3Rpb24o
-YSxiLGMpe2lmKDA+YXx8YT5jKXRocm93IEguYihQLlRFKGEsMCxjLCJzdGFydCIsbnVsbCkpCmlmKGIh
-PW51bGwpe2lmKGE+Ynx8Yj5jKXRocm93IEguYihQLlRFKGIsYSxjLCJlbmQiLG51bGwpKQpyZXR1cm4g
-Yn1yZXR1cm4gY30sCmsxOmZ1bmN0aW9uKGEsYil7aWYoYTwwKXRocm93IEguYihQLlRFKGEsMCxudWxs
-LGIsbnVsbCkpCnJldHVybiBhfSwKQ2Y6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz1ILnVQKGU9PW51
-bGw/Si5IbShiKTplKQpyZXR1cm4gbmV3IFAuZVkocywhMCxhLGMsIkluZGV4IG91dCBvZiByYW5nZSIp
-fSwKTDQ6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLnViKGEpfSwKU1k6ZnVuY3Rpb24oYSl7cmV0dXJu
-IG5ldyBQLmRzKGEpfSwKUFY6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLmxqKGEpfSwKYTQ6ZnVuY3Rp
-b24oYSl7cmV0dXJuIG5ldyBQLlVWKGEpfSwKcnI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBuZXcgUC5h
-RShhLGIsYyl9LApoSzpmdW5jdGlvbihhNSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixl
-LGQsYyxiLGEsYTAsYTEsYTIsYTM9bnVsbCxhND1hNS5sZW5ndGgKaWYoYTQ+PTUpe3M9KChKLlF6KGE1
-LDQpXjU4KSozfEMueEIuVyhhNSwwKV4xMDB8Qy54Qi5XKGE1LDEpXjk3fEMueEIuVyhhNSwyKV4xMTZ8
-Qy54Qi5XKGE1LDMpXjk3KT4+PjAKaWYocz09PTApcmV0dXJuIFAuS0QoYTQ8YTQ/Qy54Qi5OaihhNSww
-LGE0KTphNSw1LGEzKS5nbFIoKQplbHNlIGlmKHM9PT0zMilyZXR1cm4gUC5LRChDLnhCLk5qKGE1LDUs
-YTQpLDAsYTMpLmdsUigpfXI9UC5POCg4LDAsITEsdC5TKQpDLk5tLlk1KHIsMCwwKQpDLk5tLlk1KHIs
-MSwtMSkKQy5ObS5ZNShyLDIsLTEpCkMuTm0uWTUociw3LC0xKQpDLk5tLlk1KHIsMywwKQpDLk5tLlk1
-KHIsNCwwKQpDLk5tLlk1KHIsNSxhNCkKQy5ObS5ZNShyLDYsYTQpCmlmKFAuVUIoYTUsMCxhNCwwLHIp
-Pj0xNClDLk5tLlk1KHIsNyxhNCkKcT1yWzFdCmlmKHE+PTApaWYoUC5VQihhNSwwLHEsMjAscik9PT0y
-MClyWzddPXEKcD1yWzJdKzEKbz1yWzNdCm49cls0XQptPXJbNV0KbD1yWzZdCmlmKGw8bSltPWwKaWYo
-bjxwKW49bQplbHNlIGlmKG48PXEpbj1xKzEKaWYobzxwKW89bgprPXJbN108MAppZihrKWlmKHA+cSsz
-KXtqPWEzCms9ITF9ZWxzZXtpPW8+MAppZihpJiZvKzE9PT1uKXtqPWEzCms9ITF9ZWxzZXtpZighKG08
-YTQmJm09PT1uKzImJkoucTAoYTUsIi4uIixuKSkpaD1tPm4rMiYmSi5xMChhNSwiLy4uIixtLTMpCmVs
-c2UgaD0hMAppZihoKXtqPWEzCms9ITF9ZWxzZXtpZihxPT09NClpZihKLnEwKGE1LCJmaWxlIiwwKSl7
-aWYocDw9MCl7aWYoIUMueEIuUWkoYTUsIi8iLG4pKXtnPSJmaWxlOi8vLyIKcz0zfWVsc2V7Zz0iZmls
-ZTovLyIKcz0yfWE1PWcrQy54Qi5OaihhNSxuLGE0KQpxLT0wCmk9cy0wCm0rPWkKbCs9aQphND1hNS5s
-ZW5ndGgKcD03Cm89NwpuPTd9ZWxzZSBpZihuPT09bSl7KytsCmY9bSsxCmE1PUMueEIuaTcoYTUsbixt
-LCIvIik7KythNAptPWZ9aj0iZmlsZSJ9ZWxzZSBpZihDLnhCLlFpKGE1LCJodHRwIiwwKSl7aWYoaSYm
-byszPT09biYmQy54Qi5RaShhNSwiODAiLG8rMSkpe2wtPTMKZT1uLTMKbS09MwphNT1DLnhCLmk3KGE1
-LG8sbiwiIikKYTQtPTMKbj1lfWo9Imh0dHAifWVsc2Ugaj1hMwplbHNlIGlmKHE9PT01JiZKLnEwKGE1
-LCJodHRwcyIsMCkpe2lmKGkmJm8rND09PW4mJkoucTAoYTUsIjQ0MyIsbysxKSl7bC09NAplPW4tNApt
-LT00CmE1PUouZGcoYTUsbyxuLCIiKQphNC09MwpuPWV9aj0iaHR0cHMifWVsc2Ugaj1hMwprPSEwfX19
-ZWxzZSBqPWEzCmlmKGspe2k9YTUubGVuZ3RoCmlmKGE0PGkpe2E1PUoubGQoYTUsMCxhNCkKcS09MApw
-LT0wCm8tPTAKbi09MAptLT0wCmwtPTB9cmV0dXJuIG5ldyBQLlVmKGE1LHEscCxvLG4sbSxsLGopfWlm
-KGo9PW51bGwpaWYocT4wKWo9UC5QaShhNSwwLHEpCmVsc2V7aWYocT09PTApe1AuUjMoYTUsMCwiSW52
-YWxpZCBlbXB0eSBzY2hlbWUiKQpILkJpKHUuZyl9aj0iIn1pZihwPjApe2Q9cSszCmM9ZDxwP1AuelIo
-YTUsZCxwLTEpOiIiCmI9UC5PZShhNSxwLG8sITEpCmk9bysxCmlmKGk8bil7YT1ILkhwKEoubGQoYTUs
-aSxuKSxhMykKYTA9UC53QihhPT1udWxsP0gudihQLnJyKCJJbnZhbGlkIHBvcnQiLGE1LGkpKTphLGop
-fWVsc2UgYTA9YTN9ZWxzZXthMD1hMwpiPWEwCmM9IiJ9YTE9UC5rYShhNSxuLG0sYTMsaixiIT1udWxs
-KQphMj1tPGw/UC5sZShhNSxtKzEsbCxhMyk6YTMKcmV0dXJuIG5ldyBQLkRuKGosYyxiLGEwLGExLGEy
-LGw8YTQ/UC50RyhhNSxsKzEsYTQpOmEzKX0sCk10OmZ1bmN0aW9uKGEpe0guaChhKQpyZXR1cm4gUC5r
-dShhLDAsYS5sZW5ndGgsQy54TSwhMSl9LApXWDpmdW5jdGlvbihhKXt2YXIgcz10Lk4KcmV0dXJuIEMu
-Tm0uTjAoSC5WTShhLnNwbGl0KCImIiksdC5zKSxQLkZsKHMscyksbmV3IFAubjEoQy54TSksdC5KKX0s
-CkhoOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbT0iSVB2NCBhZGRyZXNzIHNob3VsZCBj
-b250YWluIGV4YWN0bHkgNCBwYXJ0cyIsbD0iZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIDAu
-LjI1NSIsaz1uZXcgUC5jUyhhKSxqPW5ldyBVaW50OEFycmF5KDQpCmZvcihzPWIscj1zLHE9MDtzPGM7
-KytzKXtwPUMueEIuTzIoYSxzKQppZihwIT09NDYpe2lmKChwXjQ4KT45KWsuJDIoImludmFsaWQgY2hh
-cmFjdGVyIixzKX1lbHNle2lmKHE9PT0zKWsuJDIobSxzKQpvPVAuUUEoQy54Qi5OaihhLHIscyksbnVs
-bCkKaWYobz4yNTUpay4kMihsLHIpCm49cSsxCmlmKHE+PTQpcmV0dXJuIEguT0goaixxKQpqW3FdPW8K
-cj1zKzEKcT1ufX1pZihxIT09MylrLiQyKG0sYykKbz1QLlFBKEMueEIuTmooYSxyLGMpLG51bGwpCmlm
-KG8+MjU1KWsuJDIobCxyKQppZihxPj00KXJldHVybiBILk9IKGoscSkKaltxXT1vCnJldHVybiBqfSwK
-ZWc6ZnVuY3Rpb24oYSxiLGEwKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZD1uZXcg
-UC5WQyhhKSxjPW5ldyBQLkpUKGQsYSkKaWYoYS5sZW5ndGg8MilkLiQxKCJhZGRyZXNzIGlzIHRvbyBz
-aG9ydCIpCnM9SC5WTShbXSx0LmEpCmZvcihyPWIscT1yLHA9ITEsbz0hMTtyPGEwOysrcil7bj1DLnhC
-Lk8yKGEscikKaWYobj09PTU4KXtpZihyPT09Yil7KytyCmlmKEMueEIuTzIoYSxyKSE9PTU4KWQuJDIo
-ImludmFsaWQgc3RhcnQgY29sb24uIixyKQpxPXJ9aWYocj09PXEpe2lmKHApZC4kMigib25seSBvbmUg
-d2lsZGNhcmQgYDo6YCBpcyBhbGxvd2VkIixyKQpDLk5tLmkocywtMSkKcD0hMH1lbHNlIEMuTm0uaShz
-LGMuJDIocSxyKSkKcT1yKzF9ZWxzZSBpZihuPT09NDYpbz0hMH1pZihzLmxlbmd0aD09PTApZC4kMSgi
-dG9vIGZldyBwYXJ0cyIpCm09cT09PWEwCmw9Qy5ObS5ncloocykKaWYobSYmbCE9PS0xKWQuJDIoImV4
-cGVjdGVkIGEgcGFydCBhZnRlciBsYXN0IGA6YCIsYTApCmlmKCFtKWlmKCFvKUMuTm0uaShzLGMuJDIo
-cSxhMCkpCmVsc2V7az1QLkhoKGEscSxhMCkKQy5ObS5pKHMsKGtbMF08PDh8a1sxXSk+Pj4wKQpDLk5t
-Lmkocywoa1syXTw8OHxrWzNdKT4+PjApfWlmKHApe2lmKHMubGVuZ3RoPjcpZC4kMSgiYW4gYWRkcmVz
-cyB3aXRoIGEgd2lsZGNhcmQgbXVzdCBoYXZlIGxlc3MgdGhhbiA3IHBhcnRzIil9ZWxzZSBpZihzLmxl
-bmd0aCE9PTgpZC4kMSgiYW4gYWRkcmVzcyB3aXRob3V0IGEgd2lsZGNhcmQgbXVzdCBjb250YWluIGV4
-YWN0bHkgOCBwYXJ0cyIpCmo9bmV3IFVpbnQ4QXJyYXkoMTYpCmZvcihsPXMubGVuZ3RoLGk9OS1sLHI9
-MCxoPTA7cjxsOysrcil7Zz1zW3JdCmlmKGc9PT0tMSlmb3IoZj0wO2Y8aTsrK2Ype2lmKGg8MHx8aD49
-MTYpcmV0dXJuIEguT0goaixoKQpqW2hdPTAKZT1oKzEKaWYoZT49MTYpcmV0dXJuIEguT0goaixlKQpq
-W2VdPTAKaCs9Mn1lbHNle2U9Qy5qbi53RyhnLDgpCmlmKGg8MHx8aD49MTYpcmV0dXJuIEguT0goaixo
-KQpqW2hdPWUKZT1oKzEKaWYoZT49MTYpcmV0dXJuIEguT0goaixlKQpqW2VdPWcmMjU1CmgrPTJ9fXJl
-dHVybiBqfSwKS0w6ZnVuY3Rpb24oYSxiLGMsZCxlLGYsZyl7dmFyIHMscixxLHAsbyxuCmY9Zj09bnVs
-bD8iIjpQLlBpKGYsMCxmLmxlbmd0aCkKZz1QLnpSKGcsMCxnPT1udWxsPzA6Zy5sZW5ndGgpCmE9UC5P
-ZShhLDAsYT09bnVsbD8wOmEubGVuZ3RoLCExKQpzPVAubGUobnVsbCwwLDAsZSkKcj1QLnRHKG51bGws
-MCwwKQpkPVAud0IoZCxmKQpxPWY9PT0iZmlsZSIKaWYoYT09bnVsbClwPWcubGVuZ3RoIT09MHx8ZCE9
-bnVsbHx8cQplbHNlIHA9ITEKaWYocClhPSIiCnA9YT09bnVsbApvPSFwCmI9UC5rYShiLDAsYj09bnVs
-bD8wOmIubGVuZ3RoLGMsZixvKQpuPWYubGVuZ3RoPT09MAppZihuJiZwJiYhQy54Qi5uQyhiLCIvIikp
-Yj1QLndGKGIsIW58fG8pCmVsc2UgYj1QLnhlKGIpCnJldHVybiBuZXcgUC5EbihmLGcscCYmQy54Qi5u
-QyhiLCIvLyIpPyIiOmEsZCxiLHMscil9LAp3SzpmdW5jdGlvbihhKXtpZihhPT09Imh0dHAiKXJldHVy
-biA4MAppZihhPT09Imh0dHBzIilyZXR1cm4gNDQzCnJldHVybiAwfSwKUjM6ZnVuY3Rpb24oYSxiLGMp
-e3Rocm93IEguYihQLnJyKGMsYSxiKSl9LApYZDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxv
-LG4sbSxsLGssaixpLGg9bnVsbCxnPWIubGVuZ3RoCmlmKGchPT0wKXtxPTAKd2hpbGUoITApe2lmKCEo
-cTxnKSl7cz0iIgpyPTAKYnJlYWt9aWYoQy54Qi5XKGIscSk9PT02NCl7cz1DLnhCLk5qKGIsMCxxKQpy
-PXErMQpicmVha30rK3F9aWYocjxnJiZDLnhCLlcoYixyKT09PTkxKXtmb3IocD1yLG89LTE7cDxnOysr
-cCl7bj1DLnhCLlcoYixwKQppZihuPT09MzcmJm88MCl7bT1DLnhCLlFpKGIsIjI1IixwKzEpP3ArMjpw
-Cm89cApwPW19ZWxzZSBpZihuPT09OTMpYnJlYWt9aWYocD09PWcpdGhyb3cgSC5iKFAucnIoIkludmFs
-aWQgSVB2NiBob3N0IGVudHJ5LiIsYixyKSkKbD1vPDA/cDpvClAuZWcoYixyKzEsbCk7KytwCmlmKHAh
-PT1nJiZDLnhCLlcoYixwKSE9PTU4KXRocm93IEguYihQLnJyKCJJbnZhbGlkIGVuZCBvZiBhdXRob3Jp
-dHkiLGIscCkpfWVsc2UgcD1yCndoaWxlKCEwKXtpZighKHA8Zykpe2s9aApicmVha31pZihDLnhCLlco
-YixwKT09PTU4KXtqPUMueEIueW4oYixwKzEpCms9ai5sZW5ndGghPT0wP1AuUUEoaixoKTpoCmJyZWFr
-fSsrcH1pPUMueEIuTmooYixyLHApfWVsc2V7az1oCmk9awpzPSIifXJldHVybiBQLktMKGksaCxILlZN
-KGMuc3BsaXQoIi8iKSx0LnMpLGssZCxhLHMpfSwKa0U6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxv
-CmZvcihzPWEubGVuZ3RoLHI9MDtyPHM7KytyKXtxPWFbcl0KcS50b1N0cmluZwpwPUouVTYocSkKbz1w
-LmdBKHEpCmlmKDA+bylILnYoUC5URSgwLDAscC5nQShxKSxudWxsLG51bGwpKQppZihILlNRKHEsIi8i
-LDApKXtzPVAuTDQoIklsbGVnYWwgcGF0aCBjaGFyYWN0ZXIgIitILkVqKHEpKQp0aHJvdyBILmIocyl9
-fX0sCkhOOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEKZm9yKHM9SC5xQyhhLGMsbnVsbCxILnQ2KGEp
-LmMpLHM9bmV3IEguYTcocyxzLmdBKHMpLHMuJHRpLkMoImE3PGFMLkU+IikpO3MuRigpOyl7cj1zLmQK
-cT1QLm51KCdbIiovOjw+P1xcXFx8XScpCnIudG9TdHJpbmcKaWYoSC5TUShyLHEsMCkpe3M9UC5MNCgi
-SWxsZWdhbCBjaGFyYWN0ZXIgaW4gcGF0aDogIityKQp0aHJvdyBILmIocyl9fX0sCnJnOmZ1bmN0aW9u
-KGEsYil7dmFyIHMKaWYoISg2NTw9YSYmYTw9OTApKXM9OTc8PWEmJmE8PTEyMgplbHNlIHM9ITAKaWYo
-cylyZXR1cm4Kcz1QLkw0KCJJbGxlZ2FsIGRyaXZlIGxldHRlciAiK1AuT28oYSkpCnRocm93IEguYihz
-KX0sCndCOmZ1bmN0aW9uKGEsYil7aWYoYSE9bnVsbCYmYT09PVAud0soYikpcmV0dXJuIG51bGwKcmV0
-dXJuIGF9LApPZTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4KaWYoYT09bnVsbClyZXR1
-cm4gbnVsbAppZihiPT09YylyZXR1cm4iIgppZihDLnhCLk8yKGEsYik9PT05MSl7cz1jLTEKaWYoQy54
-Qi5PMihhLHMpIT09OTMpe1AuUjMoYSxiLCJNaXNzaW5nIGVuZCBgXWAgdG8gbWF0Y2ggYFtgIGluIGhv
-c3QiKQpILkJpKHUuZyl9cj1iKzEKcT1QLnRvKGEscixzKQppZihxPHMpe3A9cSsxCm89UC5PQShhLEMu
-eEIuUWkoYSwiMjUiLHApP3ErMzpwLHMsIiUyNSIpfWVsc2Ugbz0iIgpQLmVnKGEscixxKQpyZXR1cm4g
-Qy54Qi5OaihhLGIscSkudG9Mb3dlckNhc2UoKStvKyJdIn1mb3Iobj1iO248YzsrK24paWYoQy54Qi5P
-MihhLG4pPT09NTgpe3E9Qy54Qi5YVShhLCIlIixiKQpxPXE+PWImJnE8Yz9xOmMKaWYocTxjKXtwPXEr
-MQpvPVAuT0EoYSxDLnhCLlFpKGEsIjI1IixwKT9xKzM6cCxjLCIlMjUiKX1lbHNlIG89IiIKUC5lZyhh
-LGIscSkKcmV0dXJuIlsiK0MueEIuTmooYSxiLHEpK28rIl0ifXJldHVybiBQLk9MKGEsYixjKX0sCnRv
-OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1DLnhCLlhVKGEsIiUiLGIpCnJldHVybiBzPj1iJiZzPGM/czpj
-fSwKT0E6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT1kIT09IiI/bmV3
-IFAuUm4oZCk6bnVsbApmb3Iocz1iLHI9cyxxPSEwO3M8Yzspe3A9Qy54Qi5PMihhLHMpCmlmKHA9PT0z
-Nyl7bz1QLnJ2KGEscywhMCkKbj1vPT1udWxsCmlmKG4mJnEpe3MrPTMKY29udGludWV9aWYoaT09bnVs
-bClpPW5ldyBQLlJuKCIiKQptPWkuYSs9Qy54Qi5OaihhLHIscykKaWYobilvPUMueEIuTmooYSxzLHMr
-MykKZWxzZSBpZihvPT09IiUiKXtQLlIzKGEscywiWm9uZUlEIHNob3VsZCBub3QgY29udGFpbiAlIGFu
-eW1vcmUiKQpILkJpKHUuZyl9aS5hPW0rbwpzKz0zCnI9cwpxPSEwfWVsc2V7aWYocDwxMjcpe249cD4+
-PjQKaWYobj49OClyZXR1cm4gSC5PSChDLkYzLG4pCm49KEMuRjNbbl0mMTw8KHAmMTUpKSE9PTB9ZWxz
-ZSBuPSExCmlmKG4pe2lmKHEmJjY1PD1wJiY5MD49cCl7aWYoaT09bnVsbClpPW5ldyBQLlJuKCIiKQpp
-ZihyPHMpe2kuYSs9Qy54Qi5OaihhLHIscykKcj1zfXE9ITF9KytzfWVsc2V7aWYoKHAmNjQ1MTIpPT09
-NTUyOTYmJnMrMTxjKXtsPUMueEIuTzIoYSxzKzEpCmlmKChsJjY0NTEyKT09PTU2MzIwKXtwPShwJjEw
-MjMpPDwxMHxsJjEwMjN8NjU1MzYKaz0yfWVsc2Ugaz0xfWVsc2Ugaz0xCmo9Qy54Qi5OaihhLHIscykK
-aWYoaT09bnVsbCl7aT1uZXcgUC5SbigiIikKbj1pfWVsc2Ugbj1pCm4uYSs9agpuLmErPVAuelgocCkK
-cys9awpyPXN9fX1pZihpPT1udWxsKXJldHVybiBDLnhCLk5qKGEsYixjKQppZihyPGMpaS5hKz1DLnhC
-Lk5qKGEscixjKQpuPWkuYQpyZXR1cm4gbi5jaGFyQ29kZUF0KDApPT0wP246bn0sCk9MOmZ1bmN0aW9u
-KGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpCmZvcihzPWIscj1zLHE9bnVsbCxwPSEwO3M8
-Yzspe289Qy54Qi5PMihhLHMpCmlmKG89PT0zNyl7bj1QLnJ2KGEscywhMCkKbT1uPT1udWxsCmlmKG0m
-JnApe3MrPTMKY29udGludWV9aWYocT09bnVsbClxPW5ldyBQLlJuKCIiKQpsPUMueEIuTmooYSxyLHMp
-Cms9cS5hKz0hcD9sLnRvTG93ZXJDYXNlKCk6bAppZihtKXtuPUMueEIuTmooYSxzLHMrMykKaj0zfWVs
-c2UgaWYobj09PSIlIil7bj0iJTI1IgpqPTF9ZWxzZSBqPTMKcS5hPWsrbgpzKz1qCnI9cwpwPSEwfWVs
-c2V7aWYobzwxMjcpe209bz4+PjQKaWYobT49OClyZXR1cm4gSC5PSChDLmVhLG0pCm09KEMuZWFbbV0m
-MTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSExCmlmKG0pe2lmKHAmJjY1PD1vJiY5MD49byl7aWYocT09bnVs
-bClxPW5ldyBQLlJuKCIiKQppZihyPHMpe3EuYSs9Qy54Qi5OaihhLHIscykKcj1zfXA9ITF9KytzfWVs
-c2V7aWYobzw9OTMpe209bz4+PjQKaWYobT49OClyZXR1cm4gSC5PSChDLmFrLG0pCm09KEMuYWtbbV0m
-MTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSExCmlmKG0pe1AuUjMoYSxzLCJJbnZhbGlkIGNoYXJhY3RlciIp
-CkguQmkodS5nKX1lbHNle2lmKChvJjY0NTEyKT09PTU1Mjk2JiZzKzE8Yyl7aT1DLnhCLk8yKGEscysx
-KQppZigoaSY2NDUxMik9PT01NjMyMCl7bz0obyYxMDIzKTw8MTB8aSYxMDIzfDY1NTM2Cmo9Mn1lbHNl
-IGo9MX1lbHNlIGo9MQpsPUMueEIuTmooYSxyLHMpCmlmKCFwKWw9bC50b0xvd2VyQ2FzZSgpCmlmKHE9
-PW51bGwpe3E9bmV3IFAuUm4oIiIpCm09cX1lbHNlIG09cQptLmErPWwKbS5hKz1QLnpYKG8pCnMrPWoK
-cj1zfX19fWlmKHE9PW51bGwpcmV0dXJuIEMueEIuTmooYSxiLGMpCmlmKHI8Yyl7bD1DLnhCLk5qKGEs
-cixjKQpxLmErPSFwP2wudG9Mb3dlckNhc2UoKTpsfW09cS5hCnJldHVybiBtLmNoYXJDb2RlQXQoMCk9
-PTA/bTptfSwKUGk6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwLG89dS5nCmlmKGI9PT1jKXJldHVy
-biIiCmlmKCFQLkV0KEouclkoYSkuVyhhLGIpKSl7UC5SMyhhLGIsIlNjaGVtZSBub3Qgc3RhcnRpbmcg
-d2l0aCBhbHBoYWJldGljIGNoYXJhY3RlciIpCkguQmkobyl9Zm9yKHM9YixyPSExO3M8YzsrK3Mpe3E9
-Qy54Qi5XKGEscykKaWYocTwxMjgpe3A9cT4+PjQKaWYocD49OClyZXR1cm4gSC5PSChDLm1LLHApCnA9
-KEMubUtbcF0mMTw8KHEmMTUpKSE9PTB9ZWxzZSBwPSExCmlmKCFwKXtQLlIzKGEscywiSWxsZWdhbCBz
-Y2hlbWUgY2hhcmFjdGVyIikKSC5CaShvKX1pZig2NTw9cSYmcTw9OTApcj0hMH1hPUMueEIuTmooYSxi
-LGMpCnJldHVybiBQLllhKHI/YS50b0xvd2VyQ2FzZSgpOmEpfSwKWWE6ZnVuY3Rpb24oYSl7aWYoYT09
-PSJodHRwIilyZXR1cm4iaHR0cCIKaWYoYT09PSJmaWxlIilyZXR1cm4iZmlsZSIKaWYoYT09PSJodHRw
-cyIpcmV0dXJuImh0dHBzIgppZihhPT09InBhY2thZ2UiKXJldHVybiJwYWNrYWdlIgpyZXR1cm4gYX0s
-CnpSOmZ1bmN0aW9uKGEsYixjKXtpZihhPT1udWxsKXJldHVybiIiCnJldHVybiBQLlBJKGEsYixjLEMu
-dG8sITEpfSwKa2E6ZnVuY3Rpb24oYSxiLGMsZCxlLGYpe3ZhciBzLHIscT1lPT09ImZpbGUiLHA9cXx8
-ZgppZihhPT1udWxsKXtpZihkPT1udWxsKXJldHVybiBxPyIvIjoiIgpzPUgudDYoZCkKcj1uZXcgSC5s
-SihkLHMuQygicVUoMSkiKS5hKG5ldyBQLlJaKCkpLHMuQygibEo8MSxxVT4iKSkuaygwLCIvIil9ZWxz
-ZSBpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJCb3RoIHBhdGggYW5kIHBhdGhTZWdtZW50cyBzcGVj
-aWZpZWQiKSkKZWxzZSByPVAuUEkoYSxiLGMsQy5XZCwhMCkKaWYoci5sZW5ndGg9PT0wKXtpZihxKXJl
-dHVybiIvIn1lbHNlIGlmKHAmJiFDLnhCLm5DKHIsIi8iKSlyPSIvIityCnJldHVybiBQLkpyKHIsZSxm
-KX0sCkpyOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1iLmxlbmd0aD09PTAKaWYocyYmIWMmJiFDLnhCLm5D
-KGEsIi8iKSlyZXR1cm4gUC53RihhLCFzfHxjKQpyZXR1cm4gUC54ZShhKX0sCmxlOmZ1bmN0aW9uKGEs
-YixjLGQpe3ZhciBzLHI9e30KaWYoYSE9bnVsbCl7aWYoZCE9bnVsbCl0aHJvdyBILmIoUC54WSgiQm90
-aCBxdWVyeSBhbmQgcXVlcnlQYXJhbWV0ZXJzIHNwZWNpZmllZCIpKQpyZXR1cm4gUC5QSShhLGIsYyxD
-LlZDLCEwKX1pZihkPT1udWxsKXJldHVybiBudWxsCnM9bmV3IFAuUm4oIiIpCnIuYT0iIgpkLksoMCxu
-ZXcgUC55NShuZXcgUC5NRShyLHMpKSkKcj1zLmEKcmV0dXJuIHIuY2hhckNvZGVBdCgwKT09MD9yOnJ9
-LAp0RzpmdW5jdGlvbihhLGIsYyl7aWYoYT09bnVsbClyZXR1cm4gbnVsbApyZXR1cm4gUC5QSShhLGIs
-YyxDLlZDLCEwKX0sCnJ2OmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG49YisyCmlmKG4+PWEu
-bGVuZ3RoKXJldHVybiIlIgpzPUMueEIuTzIoYSxiKzEpCnI9Qy54Qi5PMihhLG4pCnE9SC5vbyhzKQpw
-PUgub28ocikKaWYocTwwfHxwPDApcmV0dXJuIiUiCm89cSoxNitwCmlmKG88MTI3KXtuPUMuam4ud0co
-byw0KQppZihuPj04KXJldHVybiBILk9IKEMuRjMsbikKbj0oQy5GM1tuXSYxPDwobyYxNSkpIT09MH1l
-bHNlIG49ITEKaWYobilyZXR1cm4gSC5MdyhjJiY2NTw9byYmOTA+PW8/KG98MzIpPj4+MDpvKQppZihz
-Pj05N3x8cj49OTcpcmV0dXJuIEMueEIuTmooYSxiLGIrMykudG9VcHBlckNhc2UoKQpyZXR1cm4gbnVs
-bH0sCnpYOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsaz0iMDEyMzQ1Njc4OUFCQ0RFRiIK
-aWYoYTwxMjgpe3M9bmV3IFVpbnQ4QXJyYXkoMykKc1swXT0zNwpzWzFdPUMueEIuVyhrLGE+Pj40KQpz
-WzJdPUMueEIuVyhrLGEmMTUpfWVsc2V7aWYoYT4yMDQ3KWlmKGE+NjU1MzUpe3I9MjQwCnE9NH1lbHNl
-e3I9MjI0CnE9M31lbHNle3I9MTkyCnE9Mn1wPTMqcQpzPW5ldyBVaW50OEFycmF5KHApCmZvcihvPTA7
-LS1xLHE+PTA7cj0xMjgpe249Qy5qbi5iZihhLDYqcSkmNjN8cgppZihvPj1wKXJldHVybiBILk9IKHMs
-bykKc1tvXT0zNwptPW8rMQpsPUMueEIuVyhrLG4+Pj40KQppZihtPj1wKXJldHVybiBILk9IKHMsbSkK
-c1ttXT1sCmw9bysyCm09Qy54Qi5XKGssbiYxNSkKaWYobD49cClyZXR1cm4gSC5PSChzLGwpCnNbbF09
-bQpvKz0zfX1yZXR1cm4gUC5ITShzLDAsbnVsbCl9LApQSTpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBz
-PVAuVWwoYSxiLGMsZCxlKQpyZXR1cm4gcz09bnVsbD9DLnhCLk5qKGEsYixjKTpzfSwKVWw6ZnVuY3Rp
-b24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaj1udWxsCmZvcihzPSFlLHI9YixxPXIs
-cD1qO3I8Yzspe289Qy54Qi5PMihhLHIpCmlmKG88MTI3KXtuPW8+Pj40CmlmKG4+PTgpcmV0dXJuIEgu
-T0goZCxuKQpuPShkW25dJjE8PChvJjE1KSkhPT0wfWVsc2Ugbj0hMQppZihuKSsrcgplbHNle2lmKG89
-PT0zNyl7bT1QLnJ2KGEsciwhMSkKaWYobT09bnVsbCl7cis9Mwpjb250aW51ZX1pZigiJSI9PT1tKXtt
-PSIlMjUiCmw9MX1lbHNlIGw9M31lbHNle2lmKHMpaWYobzw9OTMpe249bz4+PjQKaWYobj49OClyZXR1
-cm4gSC5PSChDLmFrLG4pCm49KEMuYWtbbl0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBuPSExCmVsc2Ugbj0h
-MQppZihuKXtQLlIzKGEsciwiSW52YWxpZCBjaGFyYWN0ZXIiKQpILkJpKHUuZykKbD1qCm09bH1lbHNl
-e2lmKChvJjY0NTEyKT09PTU1Mjk2KXtuPXIrMQppZihuPGMpe2s9Qy54Qi5PMihhLG4pCmlmKChrJjY0
-NTEyKT09PTU2MzIwKXtvPShvJjEwMjMpPDwxMHxrJjEwMjN8NjU1MzYKbD0yfWVsc2UgbD0xfWVsc2Ug
-bD0xfWVsc2UgbD0xCm09UC56WChvKX19aWYocD09bnVsbCl7cD1uZXcgUC5SbigiIikKbj1wfWVsc2Ug
-bj1wCm4uYSs9Qy54Qi5OaihhLHEscikKbi5hKz1ILkVqKG0pCmlmKHR5cGVvZiBsIT09Im51bWJlciIp
-cmV0dXJuIEgucFkobCkKcis9bApxPXJ9fWlmKHA9PW51bGwpcmV0dXJuIGoKaWYocTxjKXAuYSs9Qy54
-Qi5OaihhLHEsYykKcz1wLmEKcmV0dXJuIHMuY2hhckNvZGVBdCgwKT09MD9zOnN9LAp5QjpmdW5jdGlv
-bihhKXtpZihDLnhCLm5DKGEsIi4iKSlyZXR1cm4hMApyZXR1cm4gQy54Qi5PWShhLCIvLiIpIT09LTF9
-LAp4ZTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbQppZighUC55QihhKSlyZXR1cm4gYQpzPUgu
-Vk0oW10sdC5zKQpmb3Iocj1hLnNwbGl0KCIvIikscT1yLmxlbmd0aCxwPSExLG89MDtvPHE7KytvKXtu
-PXJbb10KaWYoSi5STShuLCIuLiIpKXttPXMubGVuZ3RoCmlmKG0hPT0wKXtpZigwPj1tKXJldHVybiBI
-Lk9IKHMsLTEpCnMucG9wKCkKaWYocy5sZW5ndGg9PT0wKUMuTm0uaShzLCIiKX1wPSEwfWVsc2UgaWYo
-Ii4iPT09bilwPSEwCmVsc2V7Qy5ObS5pKHMsbikKcD0hMX19aWYocClDLk5tLmkocywiIikKcmV0dXJu
-IEMuTm0uayhzLCIvIil9LAp3RjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbgppZighUC55Qihh
-KSlyZXR1cm4hYj9QLkMxKGEpOmEKcz1ILlZNKFtdLHQucykKZm9yKHI9YS5zcGxpdCgiLyIpLHE9ci5s
-ZW5ndGgscD0hMSxvPTA7bzxxOysrbyl7bj1yW29dCmlmKCIuLiI9PT1uKWlmKHMubGVuZ3RoIT09MCYm
-Qy5ObS5ncloocykhPT0iLi4iKXtpZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgp
-CnA9ITB9ZWxzZXtDLk5tLmkocywiLi4iKQpwPSExfWVsc2UgaWYoIi4iPT09bilwPSEwCmVsc2V7Qy5O
-bS5pKHMsbikKcD0hMX19cj1zLmxlbmd0aAppZihyIT09MClpZihyPT09MSl7aWYoMD49cilyZXR1cm4g
-SC5PSChzLDApCnI9c1swXS5sZW5ndGg9PT0wfWVsc2Ugcj0hMQplbHNlIHI9ITAKaWYocilyZXR1cm4i
-Li8iCmlmKHB8fEMuTm0uZ3JaKHMpPT09Ii4uIilDLk5tLmkocywiIikKaWYoIWIpe2lmKDA+PXMubGVu
-Z3RoKXJldHVybiBILk9IKHMsMCkKQy5ObS5ZNShzLDAsUC5DMShzWzBdKSl9cmV0dXJuIEMuTm0uayhz
-LCIvIil9LApDMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLmxlbmd0aAppZihwPj0yJiZQLkV0KEou
-UXooYSwwKSkpZm9yKHM9MTtzPHA7KytzKXtyPUMueEIuVyhhLHMpCmlmKHI9PT01OClyZXR1cm4gQy54
-Qi5OaihhLDAscykrIiUzQSIrQy54Qi55bihhLHMrMSkKaWYocjw9MTI3KXtxPXI+Pj40CmlmKHE+PTgp
-cmV0dXJuIEguT0goQy5tSyxxKQpxPShDLm1LW3FdJjE8PChyJjE1KSk9PT0wfWVsc2UgcT0hMAppZihx
-KWJyZWFrfXJldHVybiBhfSwKbW46ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9YS5nRmooKSxvPXAubGVu
-Z3RoCmlmKG8+MCYmSi5IbShwWzBdKT09PTImJkouYTYocFswXSwxKT09PTU4KXtpZigwPj1vKXJldHVy
-biBILk9IKHAsMCkKUC5yZyhKLmE2KHBbMF0sMCksITEpClAuSE4ocCwhMSwxKQpzPSEwfWVsc2V7UC5I
-TihwLCExLDApCnM9ITF9cj1hLmd0VCgpJiYhcz8iXFwiOiIiCmlmKGEuZ2NqKCkpe3E9YS5nSmYoYSkK
-aWYocS5sZW5ndGghPT0wKXI9cisiXFwiK3ErIlxcIn1yPVAudmcocixwLCJcXCIpCm89cyYmbz09PTE/
-cisiXFwiOnIKcmV0dXJuIG8uY2hhckNvZGVBdCgwKT09MD9vOm99LApJaDpmdW5jdGlvbihhLGIpe3Zh
-ciBzLHIscQpmb3Iocz0wLHI9MDtyPDI7KytyKXtxPUMueEIuVyhhLGIrcikKaWYoNDg8PXEmJnE8PTU3
-KXM9cyoxNitxLTQ4CmVsc2V7cXw9MzIKaWYoOTc8PXEmJnE8PTEwMilzPXMqMTYrcS04NwplbHNlIHRo
-cm93IEguYihQLnhZKCJJbnZhbGlkIFVSTCBlbmNvZGluZyIpKX19cmV0dXJuIHN9LAprdTpmdW5jdGlv
-bihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG89Si5yWShhKSxuPWIKd2hpbGUoITApe2lmKCEobjxjKSl7
-cz0hMApicmVha31yPW8uVyhhLG4pCmlmKHI8PTEyNylpZihyIT09MzcpcT1lJiZyPT09NDMKZWxzZSBx
-PSEwCmVsc2UgcT0hMAppZihxKXtzPSExCmJyZWFrfSsrbn1pZihzKXtpZihDLnhNIT09ZClxPSExCmVs
-c2UgcT0hMAppZihxKXJldHVybiBvLk5qKGEsYixjKQplbHNlIHA9bmV3IEgucWooby5OaihhLGIsYykp
-fWVsc2V7cD1ILlZNKFtdLHQuYSkKZm9yKG49YjtuPGM7KytuKXtyPW8uVyhhLG4pCmlmKHI+MTI3KXRo
-cm93IEguYihQLnhZKCJJbGxlZ2FsIHBlcmNlbnQgZW5jb2RpbmcgaW4gVVJJIikpCmlmKHI9PT0zNyl7
-aWYobiszPmEubGVuZ3RoKXRocm93IEguYihQLnhZKCJUcnVuY2F0ZWQgVVJJIikpCkMuTm0uaShwLFAu
-SWgoYSxuKzEpKQpuKz0yfWVsc2UgaWYoZSYmcj09PTQzKUMuTm0uaShwLDMyKQplbHNlIEMuTm0uaShw
-LHIpfX10LkwuYShwKQpyZXR1cm4gQy5vRS5XSihwKX0sCkV0OmZ1bmN0aW9uKGEpe3ZhciBzPWF8MzIK
-cmV0dXJuIDk3PD1zJiZzPD0xMjJ9LApLRDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0s
-bCxrPSJJbnZhbGlkIE1JTUUgdHlwZSIsaj1ILlZNKFtiLTFdLHQuYSkKZm9yKHM9YS5sZW5ndGgscj1i
-LHE9LTEscD1udWxsO3I8czsrK3Ipe3A9Qy54Qi5XKGEscikKaWYocD09PTQ0fHxwPT09NTkpYnJlYWsK
-aWYocD09PTQ3KXtpZihxPDApe3E9cgpjb250aW51ZX10aHJvdyBILmIoUC5ycihrLGEscikpfX1pZihx
-PDAmJnI+Yil0aHJvdyBILmIoUC5ycihrLGEscikpCmZvcig7cCE9PTQ0Oyl7Qy5ObS5pKGoscik7Kyty
-CmZvcihvPS0xO3I8czsrK3Ipe3A9Qy54Qi5XKGEscikKaWYocD09PTYxKXtpZihvPDApbz1yfWVsc2Ug
-aWYocD09PTU5fHxwPT09NDQpYnJlYWt9aWYobz49MClDLk5tLmkoaixvKQplbHNle249Qy5ObS5ncloo
-aikKaWYocCE9PTQ0fHxyIT09bis3fHwhQy54Qi5RaShhLCJiYXNlNjQiLG4rMSkpdGhyb3cgSC5iKFAu
-cnIoIkV4cGVjdGluZyAnPSciLGEscikpCmJyZWFrfX1DLk5tLmkoaixyKQptPXIrMQppZigoai5sZW5n
-dGgmMSk9PT0xKWE9Qy5oOS55cihhLG0scykKZWxzZXtsPVAuVWwoYSxtLHMsQy5WQywhMCkKaWYobCE9
-bnVsbClhPUMueEIuaTcoYSxtLHMsbCl9cmV0dXJuIG5ldyBQLlBFKGEsaixjKX0sCktOOmZ1bmN0aW9u
-KCl7dmFyIHMscixxLHAsbyxuLG09IjAxMjM0NTY3ODlBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFi
-Y2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6LS5ffiEkJicoKSorLDs9IixsPSIuIixrPSI6IixqPSIvIixp
-PSI/IixoPSIjIixnPUguVk0obmV3IEFycmF5KDIyKSx0LmdOKQpmb3Iocz0wO3M8MjI7KytzKWdbc109
-bmV3IFVpbnQ4QXJyYXkoOTYpCnI9bmV3IFAueUkoZykKcT1uZXcgUC5jNigpCnA9bmV3IFAucWQoKQpv
-PXQuZ2MKbj1vLmEoci4kMigwLDIyNSkpCnEuJDMobixtLDEpCnEuJDMobixsLDE0KQpxLiQzKG4saywz
-NCkKcS4kMyhuLGosMykKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTQsMjI1
-KSkKcS4kMyhuLG0sMSkKcS4kMyhuLGwsMTUpCnEuJDMobixrLDM0KQpxLiQzKG4saiwyMzQpCnEuJDMo
-bixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDE1LDIyNSkpCnEuJDMobixtLDEpCnEuJDMo
-biwiJSIsMjI1KQpxLiQzKG4saywzNCkKcS4kMyhuLGosOSkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwy
-MDUpCm49by5hKHIuJDIoMSwyMjUpKQpxLiQzKG4sbSwxKQpxLiQzKG4saywzNCkKcS4kMyhuLGosMTAp
-CnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDIsMjM1KSkKcS4kMyhuLG0sMTM5
-KQpxLiQzKG4saiwxMzEpCnEuJDMobixsLDE0NikKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49
-by5hKHIuJDIoMywyMzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGosNjgpCnEuJDMobixsLDE4KQpxLiQz
-KG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig0LDIyOSkpCnEuJDMobixtLDUpCnAuJDMo
-biwiQVoiLDIyOSkKcS4kMyhuLGssMTAyKQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4sIlsiLDIzMikKcS4k
-MyhuLGosMTM4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig1LDIyOSkpCnEu
-JDMobixtLDUpCnAuJDMobiwiQVoiLDIyOSkKcS4kMyhuLGssMTAyKQpxLiQzKG4sIkAiLDY4KQpxLiQz
-KG4saiwxMzgpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDYsMjMxKSkKcC4k
-MyhuLCIxOSIsNykKcS4kMyhuLCJAIiw2OCkKcS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIpCnEuJDMo
-bixoLDIwNSkKbj1vLmEoci4kMig3LDIzMSkpCnAuJDMobiwiMDkiLDcpCnEuJDMobiwiQCIsNjgpCnEu
-JDMobixqLDEzOCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCnEuJDMoby5hKHIuJDIoOCw4KSks
-Il0iLDUpCm49by5hKHIuJDIoOSwyMzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTYpCnEuJDMobixq
-LDIzNCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTYsMjM1KSkKcS4kMyhu
-LG0sMTEpCnEuJDMobixsLDE3KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1
-KQpuPW8uYShyLiQyKDE3LDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiw5KQpxLiQzKG4saSwxNzIp
-CnEuJDMobixoLDIwNSkKbj1vLmEoci4kMigxMCwyMzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTgp
-CnEuJDMobixqLDIzNCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTgsMjM1
-KSkKcS4kMyhuLG0sMTEpCnEuJDMobixsLDE5KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4k
-MyhuLGgsMjA1KQpuPW8uYShyLiQyKDE5LDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiwyMzQpCnEu
-JDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDExLDIzNSkpCnEuJDMobixtLDExKQpx
-LiQzKG4saiwxMCkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTIsMjM2KSkK
-cS4kMyhuLG0sMTIpCnEuJDMobixpLDEyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTMsMjM3KSkK
-cS4kMyhuLG0sMTMpCnEuJDMobixpLDEzKQpwLiQzKG8uYShyLiQyKDIwLDI0NSkpLCJheiIsMjEpCnI9
-by5hKHIuJDIoMjEsMjQ1KSkKcC4kMyhyLCJheiIsMjEpCnAuJDMociwiMDkiLDIxKQpxLiQzKHIsIist
-LiIsMjEpCnJldHVybiBnfSwKVUI6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvLG49JC52
-WigpCmZvcihzPUouclkoYSkscj1iO3I8YzsrK3Ipe2lmKGQ8MHx8ZD49bi5sZW5ndGgpcmV0dXJuIEgu
-T0gobixkKQpxPW5bZF0KcD1zLlcoYSxyKV45NgpvPXFbcD45NT8zMTpwXQpkPW8mMzEKQy5ObS5ZNShl
-LG8+Pj41LHIpfXJldHVybiBkfSwKV0Y6ZnVuY3Rpb24gV0YoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0s
-CmlQOmZ1bmN0aW9uIGlQKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApYUzpmdW5jdGlvbiBYUygpe30s
-CkM2OmZ1bmN0aW9uIEM2KGEpe3RoaXMuYT1hfSwKRXo6ZnVuY3Rpb24gRXooKXt9LApGOmZ1bmN0aW9u
-IEYoKXt9LAp1OmZ1bmN0aW9uIHUoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9Ywpf
-LmQ9ZH0sCmJKOmZ1bmN0aW9uIGJKKGEsYixjLGQsZSxmKXt2YXIgXz10aGlzCl8uZT1hCl8uZj1iCl8u
-YT1jCl8uYj1kCl8uYz1lCl8uZD1mfSwKZVk6ZnVuY3Rpb24gZVkoYSxiLGMsZCxlKXt2YXIgXz10aGlz
-Cl8uZj1hCl8uYT1iCl8uYj1jCl8uYz1kCl8uZD1lfSwKbXA6ZnVuY3Rpb24gbXAoYSxiLGMsZCl7dmFy
-IF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZH0sCnViOmZ1bmN0aW9uIHViKGEpe3RoaXMuYT1h
-fSwKZHM6ZnVuY3Rpb24gZHMoYSl7dGhpcy5hPWF9LApsajpmdW5jdGlvbiBsaihhKXt0aGlzLmE9YX0s
-ClVWOmZ1bmN0aW9uIFVWKGEpe3RoaXMuYT1hfSwKazU6ZnVuY3Rpb24gazUoKXt9LApLWTpmdW5jdGlv
-biBLWSgpe30sCmM6ZnVuY3Rpb24gYyhhKXt0aGlzLmE9YX0sCkNEOmZ1bmN0aW9uIENEKGEpe3RoaXMu
-YT1hfSwKYUU6ZnVuY3Rpb24gYUUoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKY1g6
-ZnVuY3Rpb24gY1goKXt9LApBbjpmdW5jdGlvbiBBbigpe30sCk4zOmZ1bmN0aW9uIE4zKGEsYixjKXt0
-aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0aT1jfSwKYzg6ZnVuY3Rpb24gYzgoKXt9LApNaDpmdW5jdGlv
-biBNaCgpe30sClpkOmZ1bmN0aW9uIFpkKCl7fSwKUm46ZnVuY3Rpb24gUm4oYSl7dGhpcy5hPWF9LApu
-MTpmdW5jdGlvbiBuMShhKXt0aGlzLmE9YX0sCmNTOmZ1bmN0aW9uIGNTKGEpe3RoaXMuYT1hfSwKVkM6
-ZnVuY3Rpb24gVkMoYSl7dGhpcy5hPWF9LApKVDpmdW5jdGlvbiBKVChhLGIpe3RoaXMuYT1hCnRoaXMu
-Yj1ifSwKRG46ZnVuY3Rpb24gRG4oYSxiLGMsZCxlLGYsZyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9Ygpf
-LmM9YwpfLmQ9ZApfLmU9ZQpfLmY9ZgpfLnI9ZwpfLng9bnVsbApfLnk9ITEKXy56PW51bGwKXy5RPSEx
-Cl8uY2g9bnVsbApfLmN4PSExCl8uY3k9bnVsbApfLmRiPSExfSwKUlo6ZnVuY3Rpb24gUlooKXt9LApN
-RTpmdW5jdGlvbiBNRShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKeTU6ZnVuY3Rpb24geTUoYSl7dGhp
-cy5hPWF9LApQRTpmdW5jdGlvbiBQRShhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LAp5
-STpmdW5jdGlvbiB5SShhKXt0aGlzLmE9YX0sCmM2OmZ1bmN0aW9uIGM2KCl7fSwKcWQ6ZnVuY3Rpb24g
-cWQoKXt9LApVZjpmdW5jdGlvbiBVZihhLGIsYyxkLGUsZixnLGgpe3ZhciBfPXRoaXMKXy5hPWEKXy5i
-PWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5mPWYKXy5yPWcKXy54PWgKXy55PW51bGx9LApxZTpmdW5jdGlv
-biBxZShhLGIsYyxkLGUsZixnKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kCl8uZT1l
-Cl8uZj1mCl8ucj1nCl8ueD1udWxsCl8ueT0hMQpfLno9bnVsbApfLlE9ITEKXy5jaD1udWxsCl8uY3g9
-ITEKXy5jeT1udWxsCl8uZGI9ITF9LAppSjpmdW5jdGlvbiBpSigpe30sCmpnOmZ1bmN0aW9uIGpnKGEs
-Yil7dGhpcy5hPWEKdGhpcy5iPWJ9LApUYTpmdW5jdGlvbiBUYShhLGIpe3RoaXMuYT1hCnRoaXMuYj1i
-fSwKQmY6ZnVuY3Rpb24gQmYoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkFzOmZ1bmN0aW9uIEFzKCl7
-fSwKR0U6ZnVuY3Rpb24gR0UoYSl7dGhpcy5hPWF9LApONzpmdW5jdGlvbiBONyhhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKdVE6ZnVuY3Rpb24gdVEoKXt9LApoRjpmdW5jdGlvbiBoRigpe30sClI0OmZ1bmN0
-aW9uKGEsYixjLGQpe3ZhciBzLHIscQpILnk4KGIpCnQuai5hKGQpCmlmKEgub1QoYikpe3M9W2NdCkMu
-Tm0uRlYocyxkKQpkPXN9cj10LnoKcT1QLkNIKEouTTEoZCxQLncwKCksciksITAscikKdC5ZLmEoYSkK
-cmV0dXJuIFAud1koSC5FayhhLHEsbnVsbCkpfSwKRG06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCnRyeXtp
-ZihPYmplY3QuaXNFeHRlbnNpYmxlKGEpJiYhT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5j
-YWxsKGEsYikpe09iamVjdC5kZWZpbmVQcm9wZXJ0eShhLGIse3ZhbHVlOmN9KQpyZXR1cm4hMH19Y2F0
-Y2gocyl7SC5SdShzKX1yZXR1cm4hMX0sCk9tOmZ1bmN0aW9uKGEsYil7aWYoT2JqZWN0LnByb3RvdHlw
-ZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKGEsYikpcmV0dXJuIGFbYl0KcmV0dXJuIG51bGx9LAp3WTpmdW5j
-dGlvbihhKXtpZihhPT1udWxsfHx0eXBlb2YgYT09InN0cmluZyJ8fHR5cGVvZiBhPT0ibnVtYmVyInx8
-SC5sKGEpKXJldHVybiBhCmlmKGEgaW5zdGFuY2VvZiBQLkU0KXJldHVybiBhLmEKaWYoSC5SOShhKSly
-ZXR1cm4gYQppZih0LmFrLmIoYSkpcmV0dXJuIGEKaWYoYSBpbnN0YW5jZW9mIFAuaVApcmV0dXJuIEgu
-bzIoYSkKaWYodC5ZLmIoYSkpcmV0dXJuIFAuaEUoYSwiJGRhcnRfanNGdW5jdGlvbiIsbmV3IFAuUEMo
-KSkKcmV0dXJuIFAuaEUoYSwiXyRkYXJ0X2pzT2JqZWN0IixuZXcgUC5tdCgkLmtJKCkpKX0sCmhFOmZ1
-bmN0aW9uKGEsYixjKXt2YXIgcz1QLk9tKGEsYikKaWYocz09bnVsbCl7cz1jLiQxKGEpClAuRG0oYSxi
-LHMpfXJldHVybiBzfSwKZFU6ZnVuY3Rpb24oYSl7dmFyIHMscgppZihhPT1udWxsfHx0eXBlb2YgYT09
-InN0cmluZyJ8fHR5cGVvZiBhPT0ibnVtYmVyInx8dHlwZW9mIGE9PSJib29sZWFuIilyZXR1cm4gYQpl
-bHNlIGlmKGEgaW5zdGFuY2VvZiBPYmplY3QmJkguUjkoYSkpcmV0dXJuIGEKZWxzZSBpZihhIGluc3Rh
-bmNlb2YgT2JqZWN0JiZ0LmFrLmIoYSkpcmV0dXJuIGEKZWxzZSBpZihhIGluc3RhbmNlb2YgRGF0ZSl7
-cz1ILnVQKGEuZ2V0VGltZSgpKQppZihNYXRoLmFicyhzKTw9ODY0ZTEzKXI9ITEKZWxzZSByPSEwCmlm
-KHIpSC52KFAueFkoIkRhdGVUaW1lIGlzIG91dHNpZGUgdmFsaWQgcmFuZ2U6ICIrcykpCkguY2IoITEs
-ImlzVXRjIix0LnkpCnJldHVybiBuZXcgUC5pUChzLCExKX1lbHNlIGlmKGEuY29uc3RydWN0b3I9PT0k
-LmtJKCkpcmV0dXJuIGEubwplbHNlIHJldHVybiBQLk5EKGEpfSwKTkQ6ZnVuY3Rpb24oYSl7aWYodHlw
-ZW9mIGE9PSJmdW5jdGlvbiIpcmV0dXJuIFAuaVEoYSwkLncoKSxuZXcgUC5OeigpKQppZihhIGluc3Rh
-bmNlb2YgQXJyYXkpcmV0dXJuIFAuaVEoYSwkLlI4KCksbmV3IFAuUVMoKSkKcmV0dXJuIFAuaVEoYSwk
-LlI4KCksbmV3IFAubnAoKSl9LAppUTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9UC5PbShhLGIpCmlmKHM9
-PW51bGx8fCEoYSBpbnN0YW5jZW9mIE9iamVjdCkpe3M9Yy4kMShhKQpQLkRtKGEsYixzKX1yZXR1cm4g
-c30sClBDOmZ1bmN0aW9uIFBDKCl7fSwKbXQ6ZnVuY3Rpb24gbXQoYSl7dGhpcy5hPWF9LApOejpmdW5j
-dGlvbiBOeigpe30sClFTOmZ1bmN0aW9uIFFTKCl7fSwKbnA6ZnVuY3Rpb24gbnAoKXt9LApFNDpmdW5j
-dGlvbiBFNChhKXt0aGlzLmE9YX0sCnI3OmZ1bmN0aW9uIHI3KGEpe3RoaXMuYT1hfSwKVHo6ZnVuY3Rp
-b24gVHooYSxiKXt0aGlzLmE9YQp0aGlzLiR0aT1ifSwKY286ZnVuY3Rpb24gY28oKXt9LApuZDpmdW5j
-dGlvbiBuZCgpe30sCktlOmZ1bmN0aW9uIEtlKGEpe3RoaXMuYT1hfSwKaGk6ZnVuY3Rpb24gaGkoKXt9
-fSxXPXsKeDM6ZnVuY3Rpb24oKXtyZXR1cm4gd2luZG93fSwKWnI6ZnVuY3Rpb24oKXtyZXR1cm4gZG9j
-dW1lbnR9LApKNjpmdW5jdGlvbihhKXt2YXIgcz1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCJhIikKaWYo
-YSE9bnVsbClDLnhuLnNMVShzLGEpCnJldHVybiBzfSwKVTk6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9
-ZG9jdW1lbnQuYm9keQpyLnRvU3RyaW5nCnM9Qy5SWS5yNihyLGEsYixjKQpzLnRvU3RyaW5nCnI9dC5h
-YwpyPW5ldyBILlU1KG5ldyBXLmU3KHMpLHIuQygiYTIobEQuRSkiKS5hKG5ldyBXLkN2KCkpLHIuQygi
-VTU8bEQuRT4iKSkKcmV0dXJuIHQuaC5hKHIuZ3I4KHIpKX0sCnJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cT0iZWxlbWVudCB0YWcgdW5hdmFpbGFibGUiCnRyeXtzPUouWUUoYSkKaWYodHlwZW9mIHMuZ25zKGEp
-PT0ic3RyaW5nIilxPXMuZ25zKGEpfWNhdGNoKHIpe0guUnUocil9cmV0dXJuIHF9LApDMDpmdW5jdGlv
-bihhLGIpe2E9YStiJjUzNjg3MDkxMQphPWErKChhJjUyNDI4Nyk8PDEwKSY1MzY4NzA5MTEKcmV0dXJu
-IGFeYT4+PjZ9LApyRTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1XLkMwKFcuQzAoVy5DMChXLkMwKDAs
-YSksYiksYyksZCkscj1zKygocyY2NzEwODg2Myk8PDMpJjUzNjg3MDkxMQpyXj1yPj4+MTEKcmV0dXJu
-IHIrKChyJjE2MzgzKTw8MTUpJjUzNjg3MDkxMX0sClROOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWEu
-Y2xhc3NMaXN0CmZvcihzPWIubGVuZ3RoLHI9MDtyPGIubGVuZ3RoO2IubGVuZ3RoPT09c3x8KDAsSC5s
-aykoYiksKytyKXEuYWRkKGJbcl0pfSwKSkU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz1XLmFGKG5l
-dyBXLnZOKGMpLHQuQikKaWYocyE9bnVsbCYmITApSi5kWihhLGIscywhMSkKcmV0dXJuIG5ldyBXLnhD
-KGEsYixzLCExLGUuQygieEM8MD4iKSl9LApUdzpmdW5jdGlvbihhKXt2YXIgcz1XLko2KG51bGwpLHI9
-d2luZG93LmxvY2F0aW9uCnM9bmV3IFcuSlEobmV3IFcubWsocyxyKSkKcy5DWShhKQpyZXR1cm4gc30s
-CnFEOmZ1bmN0aW9uKGEsYixjLGQpe3QuaC5hKGEpCkguaChiKQpILmgoYykKdC5jci5hKGQpCnJldHVy
-biEwfSwKUVc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxCnQuaC5hKGEpCkguaChiKQpILmgoYykK
-cz10LmNyLmEoZCkuYQpyPXMuYQpDLnhuLnNMVShyLGMpCnE9ci5ob3N0bmFtZQpzPXMuYgppZighKHE9
-PXMuaG9zdG5hbWUmJnIucG9ydD09cy5wb3J0JiZyLnByb3RvY29sPT1zLnByb3RvY29sKSlpZihxPT09
-IiIpaWYoci5wb3J0PT09IiIpe3M9ci5wcm90b2NvbApzPXM9PT0iOiJ8fHM9PT0iIn1lbHNlIHM9ITEK
-ZWxzZSBzPSExCmVsc2Ugcz0hMApyZXR1cm4gc30sCkJsOmZ1bmN0aW9uKCl7dmFyIHM9dC5OLHI9UC50
-TShDLlF4LHMpLHE9dC5kMC5hKG5ldyBXLklBKCkpLHA9SC5WTShbIlRFTVBMQVRFIl0sdC5zKQpzPW5l
-dyBXLmN0KHIsUC5McyhzKSxQLkxzKHMpLFAuTHMocyksbnVsbCkKcy5DWShudWxsLG5ldyBILmxKKEMu
-UXgscSx0LmZqKSxwLG51bGwpCnJldHVybiBzfSwKcWM6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoYT09bnVs
-bClyZXR1cm4gbnVsbAppZigicG9zdE1lc3NhZ2UiIGluIGEpe3M9Vy5QMShhKQppZih0LmFTLmIocykp
-cmV0dXJuIHMKcmV0dXJuIG51bGx9ZWxzZSByZXR1cm4gdC5jaC5hKGEpfSwKUDE6ZnVuY3Rpb24oYSl7
-aWYoYT09PXdpbmRvdylyZXR1cm4gdC5jaS5hKGEpCmVsc2UgcmV0dXJuIG5ldyBXLmRXKCl9LAphRjpm
-dW5jdGlvbihhLGIpe3ZhciBzPSQuWDMKaWYocz09PUMuTlUpcmV0dXJuIGEKcmV0dXJuIHMuUHkoYSxi
-KX0sCnFFOmZ1bmN0aW9uIHFFKCl7fSwKR2g6ZnVuY3Rpb24gR2goKXt9LApmWTpmdW5jdGlvbiBmWSgp
-e30sCm5COmZ1bmN0aW9uIG5CKCl7fSwKQXo6ZnVuY3Rpb24gQXooKXt9LApRUDpmdW5jdGlvbiBRUCgp
-e30sCm54OmZ1bmN0aW9uIG54KCl7fSwKb0o6ZnVuY3Rpb24gb0ooKXt9LAppZDpmdW5jdGlvbiBpZCgp
-e30sClFGOmZ1bmN0aW9uIFFGKCl7fSwKTmg6ZnVuY3Rpb24gTmgoKXt9LAphZTpmdW5jdGlvbiBhZSgp
-e30sCklCOmZ1bmN0aW9uIElCKCl7fSwKbjc6ZnVuY3Rpb24gbjcoKXt9LAp3ejpmdW5jdGlvbiB3eihh
-LGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9LApjdjpmdW5jdGlvbiBjdigpe30sCkN2OmZ1bmN0aW9uIEN2
-KCl7fSwKZWE6ZnVuY3Rpb24gZWEoKXt9LApEMDpmdW5jdGlvbiBEMCgpe30sCmhIOmZ1bmN0aW9uIGhI
-KCl7fSwKaDQ6ZnVuY3Rpb24gaDQoKXt9LApicjpmdW5jdGlvbiBicigpe30sClZiOmZ1bmN0aW9uIFZi
-KCl7fSwKZko6ZnVuY3Rpb24gZkooKXt9LAp3YTpmdW5jdGlvbiB3YSgpe30sClNnOmZ1bmN0aW9uIFNn
-KCl7fSwKdzc6ZnVuY3Rpb24gdzcoKXt9LApBajpmdW5jdGlvbiBBaigpe30sCmU3OmZ1bmN0aW9uIGU3
-KGEpe3RoaXMuYT1hfSwKdUg6ZnVuY3Rpb24gdUgoKXt9LApCSDpmdW5jdGlvbiBCSCgpe30sClNOOmZ1
-bmN0aW9uIFNOKCl7fSwKZXc6ZnVuY3Rpb24gZXcoKXt9LApscDpmdW5jdGlvbiBscCgpe30sClRiOmZ1
-bmN0aW9uIFRiKCl7fSwKSXY6ZnVuY3Rpb24gSXYoKXt9LApXUDpmdW5jdGlvbiBXUCgpe30sCnlZOmZ1
-bmN0aW9uIHlZKCl7fSwKdzY6ZnVuY3Rpb24gdzYoKXt9LApLNTpmdW5jdGlvbiBLNSgpe30sCkNtOmZ1
-bmN0aW9uIENtKCl7fSwKQ1E6ZnVuY3Rpb24gQ1EoKXt9LAp3NDpmdW5jdGlvbiB3NCgpe30sCnJoOmZ1
-bmN0aW9uIHJoKCl7fSwKY2Y6ZnVuY3Rpb24gY2YoKXt9LAppNzpmdW5jdGlvbiBpNyhhKXt0aGlzLmE9
-YX0sClN5OmZ1bmN0aW9uIFN5KGEpe3RoaXMuYT1hfSwKS1M6ZnVuY3Rpb24gS1MoYSxiKXt0aGlzLmE9
-YQp0aGlzLmI9Yn0sCkEzOmZ1bmN0aW9uIEEzKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApJNDpmdW5j
-dGlvbiBJNChhKXt0aGlzLmE9YX0sCkZrOmZ1bmN0aW9uIEZrKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9
-Yn0sClJPOmZ1bmN0aW9uIFJPKGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4k
-dGk9ZH0sCmV1OmZ1bmN0aW9uIGV1KGEsYixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMK
-Xy4kdGk9ZH0sCnhDOmZ1bmN0aW9uIHhDKGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmI9YQpfLmM9Ygpf
-LmQ9YwpfLmU9ZApfLiR0aT1lfSwKdk46ZnVuY3Rpb24gdk4oYSl7dGhpcy5hPWF9LApKUTpmdW5jdGlv
-biBKUShhKXt0aGlzLmE9YX0sCkdtOmZ1bmN0aW9uIEdtKCl7fSwKdkQ6ZnVuY3Rpb24gdkQoYSl7dGhp
-cy5hPWF9LApVdjpmdW5jdGlvbiBVdihhKXt0aGlzLmE9YX0sCkVnOmZ1bmN0aW9uIEVnKGEsYixjKXt0
-aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCm02OmZ1bmN0aW9uIG02KCl7fSwKRW86ZnVuY3Rpb24g
-RW8oKXt9LApXazpmdW5jdGlvbiBXaygpe30sCmN0OmZ1bmN0aW9uIGN0KGEsYixjLGQsZSl7dmFyIF89
-dGhpcwpfLmU9YQpfLmE9YgpfLmI9YwpfLmM9ZApfLmQ9ZX0sCklBOmZ1bmN0aW9uIElBKCl7fSwKT3c6
-ZnVuY3Rpb24gT3coKXt9LApXOTpmdW5jdGlvbiBXOShhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9
-YgpfLmM9LTEKXy5kPW51bGwKXy4kdGk9Y30sCmRXOmZ1bmN0aW9uIGRXKCl7fSwKbWs6ZnVuY3Rpb24g
-bWsoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCktvOmZ1bmN0aW9uIEtvKGEpe3RoaXMuYT1hCnRoaXMu
-Yj0hMX0sCmZtOmZ1bmN0aW9uIGZtKGEpe3RoaXMuYT1hfSwKTGU6ZnVuY3Rpb24gTGUoKXt9LApLNzpm
-dW5jdGlvbiBLNygpe30sCnJCOmZ1bmN0aW9uIHJCKCl7fSwKWFc6ZnVuY3Rpb24gWFcoKXt9LApvYTpm
-dW5jdGlvbiBvYSgpe319LE09ewpPWDpmdW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSBDLkFkOnJldHVy
-biJBZGQgLyo/Ki8gaGludCIKY2FzZSBDLm5lOnJldHVybiJBZGQgLyohKi8gaGludCIKY2FzZSBDLndW
-OnJldHVybiJSZW1vdmUgLyo/Ki8gaGludCIKY2FzZSBDLmZSOnJldHVybiJSZW1vdmUgLyohKi8gaGlu
-dCIKY2FzZSBDLm15OnJldHVybiJDaGFuZ2UgdG8gLyo/Ki8gaGludCIKY2FzZSBDLnJ4OnJldHVybiJD
-aGFuZ2UgdG8gLyohKi8gaGludCJ9cmV0dXJuIG51bGx9LApINzpmdW5jdGlvbiBINyhhLGIpe3RoaXMu
-YT1hCnRoaXMuYj1ifSwKWUY6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsCmZvcihzPWIu
-bGVuZ3RoLHI9MTtyPHM7KytyKXtpZihiW3JdPT1udWxsfHxiW3ItMV0hPW51bGwpY29udGludWUKZm9y
-KDtzPj0xO3M9cSl7cT1zLTEKaWYoYltxXSE9bnVsbClicmVha31wPW5ldyBQLlJuKCIiKQpvPWErIigi
-CnAuYT1vCm49SC50NihiKQptPW4uQygibkg8MT4iKQpsPW5ldyBILm5IKGIsMCxzLG0pCmwuSGQoYiww
-LHMsbi5jKQptPW8rbmV3IEgubEoobCxtLkMoInFVKGFMLkUpIikuYShuZXcgTS5ObygpKSxtLkMoImxK
-PGFMLkUscVU+IikpLmsoMCwiLCAiKQpwLmE9bQpwLmE9bSsoIik6IHBhcnQgIisoci0xKSsiIHdhcyBu
-dWxsLCBidXQgcGFydCAiK3IrIiB3YXMgbm90LiIpCnRocm93IEguYihQLnhZKHAudygwKSkpfX0sCmxJ
-OmZ1bmN0aW9uIGxJKGEpe3RoaXMuYT1hfSwKcTc6ZnVuY3Rpb24gcTcoKXt9LApObzpmdW5jdGlvbiBO
-bygpe319LFU9ewpuejpmdW5jdGlvbihhKXt2YXIgcz1ILnVQKGEucSgwLCJub2RlSWQiKSkKcmV0dXJu
-IG5ldyBVLkxMKEMuTm0uSHQoQy5yayxuZXcgVS5NRChhKSkscyl9LApMTDpmdW5jdGlvbiBMTChhLGIp
-e3RoaXMuYT1hCnRoaXMuYj1ifSwKTUQ6ZnVuY3Rpb24gTUQoYSl7dGhpcy5hPWF9LApqZjpmdW5jdGlv
-bihhKXt2YXIgcyxyLHEscAppZihhPT1udWxsKXM9bnVsbAplbHNle3M9SC5WTShbXSx0LmQ3KQpmb3Io
-cj1KLklUKHQuVS5hKGEpKTtyLkYoKTspe3E9ci5nbCgpCnA9Si5VNihxKQpzLnB1c2gobmV3IFUuU2Uo
-SC5oKHAucShxLCJkZXNjcmlwdGlvbiIpKSxILmgocC5xKHEsImhyZWYiKSkpKX19cmV0dXJuIHN9LApO
-ZDpmdW5jdGlvbihhKXt2YXIgcyxyCmlmKGE9PW51bGwpcz1udWxsCmVsc2V7cz1ILlZNKFtdLHQuYUEp
-CmZvcihyPUouSVQodC5VLmEoYSkpO3IuRigpOylzLnB1c2goVS5OZihyLmdsKCkpKX1yZXR1cm4gc30s
-Ck5mOmZ1bmN0aW9uKGEpe3ZhciBzPUouVTYoYSkscj1ILmgocy5xKGEsImRlc2NyaXB0aW9uIikpLHE9
-SC5WTShbXSx0LmFKKQpmb3Iocz1KLklUKHQuVS5hKHMucShhLCJlbnRyaWVzIikpKTtzLkYoKTspcS5w
-dXNoKFUuUmoocy5nbCgpKSkKcmV0dXJuIG5ldyBVLnlEKHIscSl9LApSajpmdW5jdGlvbihhKXt2YXIg
-cyxyPUouVTYoYSkscT1ILmgoci5xKGEsImRlc2NyaXB0aW9uIikpLHA9SC5oKHIucShhLCJmdW5jdGlv
-biIpKSxvPXIucShhLCJsaW5rIikKaWYobz09bnVsbClvPW51bGwKZWxzZXtzPUouVTYobykKbz1uZXcg
-VS5NbChILmgocy5xKG8sImhyZWYiKSksSC51UChzLnEobywibGluZSIpKSxILmgocy5xKG8sInBhdGgi
-KSkpfXI9dC5mSy5hKHIucShhLCJoaW50QWN0aW9ucyIpKQpyPXI9PW51bGw/bnVsbDpKLk0xKHIsbmV3
-IFUuYU4oKSx0LmFYKQpyPXI9PW51bGw/bnVsbDpyLmJyKDApCnJldHVybiBuZXcgVS53YihxLHAsbyxy
-PT1udWxsP0MuZG46cil9LApkMjpmdW5jdGlvbiBkMihhLGIsYyxkLGUsZil7dmFyIF89dGhpcwpfLmE9
-YQpfLmI9YgpfLmM9YwpfLmQ9ZApfLmU9ZQpfLmY9Zn0sClNlOmZ1bmN0aW9uIFNlKGEsYil7dGhpcy5h
-PWEKdGhpcy5iPWJ9LApNbDpmdW5jdGlvbiBNbChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5j
-PWN9LAp5RDpmdW5jdGlvbiB5RChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKd2I6ZnVuY3Rpb24gd2Io
-YSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZH0sCmFOOmZ1bmN0aW9uIGFO
-KCl7fSwKYjA6ZnVuY3Rpb24gYjAoKXt9fSxCPXsKd1I6ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEIucXAo
-IiIsIiIsIiIsQy5EeCl9LApZZjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9SC5oKGEu
-cSgwLCJyZWdpb25zIikpLGo9SC5oKGEucSgwLCJuYXZpZ2F0aW9uQ29udGVudCIpKSxpPUguaChhLnEo
-MCwic291cmNlQ29kZSIpKSxoPVAuRmwodC5YLHQuZF8pCmZvcihzPXQudC5hKGEucSgwLCJlZGl0cyIp
-KSxzPXMuZ1B1KHMpLHM9cy5nbShzKSxyPXQuVSxxPXQuaDQ7cy5GKCk7KXtwPXMuZ2woKQpvPXAuYQpu
-PUguVk0oW10scSkKZm9yKHA9Si5JVChyLmEocC5iKSk7cC5GKCk7KXttPXAuZ2woKQpsPUouVTYobSkK
-bi5wdXNoKG5ldyBCLmo4KEgudVAobC5xKG0sImxpbmUiKSksSC5oKGwucShtLCJleHBsYW5hdGlvbiIp
-KSxILnVQKGwucShtLCJvZmZzZXQiKSkpKX1oLlk1KDAsbyxuKX1yZXR1cm4gbmV3IEIucXAoayxqLGks
-aCl9LApqODpmdW5jdGlvbiBqOChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApxcDpm
-dW5jdGlvbiBxcChhLGIsYyxkKXt2YXIgXz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kfSwKZnY6
-ZnVuY3Rpb24gZnYoKXt9LApPUzpmdW5jdGlvbihhKXt2YXIgcwppZighKGE+PTY1JiZhPD05MCkpcz1h
-Pj05NyYmYTw9MTIyCmVsc2Ugcz0hMApyZXR1cm4gc30sCll1OmZ1bmN0aW9uKGEsYil7dmFyIHM9YS5s
-ZW5ndGgscj1iKzIKaWYoczxyKXJldHVybiExCmlmKCFCLk9TKEMueEIuTzIoYSxiKSkpcmV0dXJuITEK
-aWYoQy54Qi5PMihhLGIrMSkhPT01OClyZXR1cm4hMQppZihzPT09cilyZXR1cm4hMApyZXR1cm4gQy54
-Qi5PMihhLHIpPT09NDd9fSxUPXttUTpmdW5jdGlvbiBtUSgpe319LEw9ewpJcTpmdW5jdGlvbigpe0Mu
-QlouQihkb2N1bWVudCwiRE9NQ29udGVudExvYWRlZCIsbmV3IEwuZSgpKQpDLm9sLkIod2luZG93LCJw
-b3BzdGF0ZSIsbmV3IEwuTCgpKX0sCmt6OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dC5nLmEoYS5wYXJlbnRO
-b2RlKS5xdWVyeVNlbGVjdG9yKCI6c2NvcGUgPiB1bCIpLHE9ci5zdHlsZSxwPSIiK0MuQ0QuelEoci5v
-ZmZzZXRIZWlnaHQpKjIrInB4IgpxLm1heEhlaWdodD1wCnE9Si5xRihhKQpwPXEuJHRpCnM9cC5DKCJ+
-KDEpPyIpLmEobmV3IEwuV3gocixhKSkKdC5aLmEobnVsbCkKVy5KRShxLmEscS5iLHMsITEscC5jKX0s
-CnlYOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG09InF1ZXJ5U2VsZWN0b3JBbGwiLGw9ZG9j
-dW1lbnQucXVlcnlTZWxlY3RvcihhKSxrPXQuZwpsLnRvU3RyaW5nCnM9dC5oCkguRGgoayxzLCJUIixt
-KQpyPXQuUgpxPW5ldyBXLnd6KGwucXVlcnlTZWxlY3RvckFsbCgiLm5hdi1saW5rIikscikKcS5LKHEs
-bmV3IEwuQU8oYikpCkguRGgoayxzLCJUIixtKQpwPW5ldyBXLnd6KGwucXVlcnlTZWxlY3RvckFsbCgi
-LnJlZ2lvbiIpLHIpCmlmKCFwLmdsMChwKSl7bz1sLnF1ZXJ5U2VsZWN0b3IoInRhYmxlW2RhdGEtcGF0
-aF0iKQpvLnRvU3RyaW5nCnAuSyhwLG5ldyBMLkhvKG8uZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcu
-U3kobmV3IFcuaTcobykpLlAoInBhdGgiKSkpKX1ILkRoKGsscywiVCIsbSkKbj1uZXcgVy53eihsLnF1
-ZXJ5U2VsZWN0b3JBbGwoIi5hZGQtaGludC1saW5rIikscikKbi5LKG4sbmV3IEwuSUMoKSl9LApRNjpm
-dW5jdGlvbihhLGIsYyl7dmFyIHM9bmV3IFhNTEh0dHBSZXF1ZXN0KCkKQy5EdC5lbyhzLCJHRVQiLEwu
-UTQoYSxiKSwhMCkKcy5zZXRSZXF1ZXN0SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9q
-c29uOyBjaGFyc2V0PVVURi04IikKcmV0dXJuIEwuTFUocyxudWxsLGMuQygiMCoiKSl9LAp0eTpmdW5j
-dGlvbihhLGIpe3ZhciBzPW5ldyBYTUxIdHRwUmVxdWVzdCgpLHI9dC5YCkMuRHQuZW8ocywiUE9TVCIs
-TC5RNChhLFAuRmwocixyKSksITApCnMuc2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC1UeXBlIiwiYXBw
-bGljYXRpb24vanNvbjsgY2hhcnNldD1VVEYtOCIpCnJldHVybiBMLkxVKHMsYix0LnQpfSwKTFU6ZnVu
-Y3Rpb24oYSxiLGMpe3JldHVybiBMLlRnKGEsYixjLGMuQygiMCoiKSl9LApUZzpmdW5jdGlvbihhLGIs
-YyxkKXt2YXIgcz0wLHI9UC5GWChkKSxxLHA9MixvLG49W10sbSxsLGssaixpLGgsZyxmCnZhciAkYXN5
-bmMkTFU9UC5seihmdW5jdGlvbihlLGEwKXtpZihlPT09MSl7bz1hMApzPXB9d2hpbGUodHJ1ZSlzd2l0
-Y2gocyl7Y2FzZSAwOmk9bmV3IFAuWmYobmV3IFAudnMoJC5YMyx0LmdWKSx0LmJDKQpoPXQuZWIKZz1o
-LmEobmV3IEwuZkMoaSxhKSkKdC5aLmEobnVsbCkKbD10LmVRClcuSkUoYSwibG9hZCIsZywhMSxsKQpX
-LkpFKGEsImVycm9yIixoLmEoaS5nWUooKSksITEsbCkKYS5zZW5kKGI9PW51bGw/bnVsbDpDLkN0Lk9C
-KGIsbnVsbCkpCnA9NApzPTcKcmV0dXJuIFAualEoaS5hLCRhc3luYyRMVSkKY2FzZSA3OnA9MgpzPTYK
-YnJlYWsKY2FzZSA0OnA9MwpmPW8KSC5SdShmKQptPUgudHMoZikKaD1QLlRsKCJFcnJvciByZWFjaGlu
-ZyBtaWdyYXRpb24gcHJldmlldyBzZXJ2ZXIuIixtKQp0aHJvdyBILmIoaCkKcz02CmJyZWFrCmNhc2Ug
-MzpzPTIKYnJlYWsKY2FzZSA2Omo9Qy5DdC5wVygwLGEucmVzcG9uc2VUZXh0LG51bGwpCmlmKGEuc3Rh
-dHVzPT09MjAwKXtxPWMuQygiMCoiKS5hKGopCnM9MQpicmVha31lbHNlIHRocm93IEguYihqKQpjYXNl
-IDE6cmV0dXJuIFAueUMocSxyKQpjYXNlIDI6cmV0dXJuIFAuZjMobyxyKX19KQpyZXR1cm4gUC5ESSgk
-YXN5bmMkTFUscil9LAphSzpmdW5jdGlvbihhKXt2YXIgcz1QLmhLKGEpLmdoWSgpLnEoMCwibGluZSIp
-CnJldHVybiBzPT1udWxsP251bGw6SC5IcChzLG51bGwpfSwKRzY6ZnVuY3Rpb24oYSl7dmFyIHM9UC5o
-SyhhKS5naFkoKS5xKDAsIm9mZnNldCIpCnJldHVybiBzPT1udWxsP251bGw6SC5IcChzLG51bGwpfSwK
-aTY6ZnVuY3Rpb24oYSl7cmV0dXJuIEwublcodC5PLmEoYSkpfSwKblc6ZnVuY3Rpb24oYSl7dmFyIHM9
-MCxyPVAuRlgodC56KSxxPTEscCxvPVtdLG4sbSxsLGssaixpLGgKdmFyICRhc3luYyRpNj1QLmx6KGZ1
-bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9YwpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOmk9
-dC5nLmEoVy5xYyhhLmN1cnJlbnRUYXJnZXQpKS5nZXRBdHRyaWJ1dGUoImhyZWYiKQphLnByZXZlbnRE
-ZWZhdWx0KCkKcT0zCms9ZG9jdW1lbnQKbj1DLkNELnpRKGsucXVlcnlTZWxlY3RvcigiLmNvbnRlbnQi
-KS5zY3JvbGxUb3ApCnM9NgpyZXR1cm4gUC5qUShMLnR5KGksbnVsbCksJGFzeW5jJGk2KQpjYXNlIDY6
-cz03CnJldHVybiBQLmpRKEwuRzcod2luZG93LmxvY2F0aW9uLnBhdGhuYW1lLG51bGwsbnVsbCwhMSxu
-dWxsKSwkYXN5bmMkaTYpCmNhc2UgNzprPWsucXVlcnlTZWxlY3RvcigiLmNvbnRlbnQiKQprLnRvU3Ry
-aW5nCmsuc2Nyb2xsVG9wPUouVnUobikKcT0xCnM9NQpicmVhawpjYXNlIDM6cT0yCmg9cAptPUguUnUo
-aCkKbD1ILnRzKGgpCkwuQzIoIkNvdWxkIG5vdCBhZGQvcmVtb3ZlIGhpbnQiLG0sbCkKcz01CmJyZWFr
-CmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQ
-LmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJGk2LHIpfSwKQzI6ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBzLHIscSxwPSJleGNlcHRpb24iLG89InN0YWNrVHJhY2UiLG49dC50LmIoYikmJkouUk0oYi5xKDAs
-InN1Y2Nlc3MiKSwhMSkmJmIueDQocCkmJmIueDQobyksbT1KLmlhKGIpCmlmKG4pe3M9SC5oKG0ucShi
-LHApKQpjPW0ucShiLG8pfWVsc2Ugcz1tLncoYikKbj1kb2N1bWVudApyPW4ucXVlcnlTZWxlY3Rvcigi
-LnBvcHVwLXBhbmUiKQpyLnF1ZXJ5U2VsZWN0b3IoImgyIikuaW5uZXJUZXh0PWEKci5xdWVyeVNlbGVj
-dG9yKCJwIikuaW5uZXJUZXh0PXMKci5xdWVyeVNlbGVjdG9yKCJwcmUiKS5pbm5lclRleHQ9Si5qKGMp
-CnE9dC5kZC5hKHIucXVlcnlTZWxlY3RvcigiYS5ib3R0b20iKSkKbT10Llg7KHEmJkMueG4pLnNMVShx
-LFAuWGQoImh0dHBzIiwiZ2l0aHViLmNvbSIsImRhcnQtbGFuZy9zZGsvaXNzdWVzL25ldyIsUC5FRihb
-InRpdGxlIiwiQ3VzdG9tZXItcmVwb3J0ZWQgaXNzdWUgd2l0aCBOTkJEIG1pZ3JhdGlvbiB0b29sOiAi
-K2EsImxhYmVscyIsdS5kLCJib2R5IixhKyJcblxuRXJyb3I6ICIrSC5FaihzKSsiXG5cblBsZWFzZSBm
-aWxsIGluIHRoZSBmb2xsb3dpbmc6XG5cbioqTmFtZSBvZiBwYWNrYWdlIGJlaW5nIG1pZ3JhdGVkIChp
-ZiBwdWJsaWMpKio6XG4qKldoYXQgSSB3YXMgZG9pbmcgd2hlbiB0aGlzIGlzc3VlIG9jY3VycmVkKio6
-XG4qKklzIGl0IHBvc3NpYmxlIHRvIHdvcmsgYXJvdW5kIHRoaXMgaXNzdWUqKjpcbioqSGFzIHRoaXMg
-aXNzdWUgaGFwcGVuZWQgYmVmb3JlLCBhbmQgaWYgc28sIGhvdyBvZnRlbioqOlxuKipEYXJ0IFNESyB2
-ZXJzaW9uKio6ICIrSC5FaihuLmdldEVsZW1lbnRCeUlkKCJzZGstdmVyc2lvbiIpLnRleHRDb250ZW50
-KSsiXG4qKkFkZGl0aW9uYWwgZGV0YWlscyoqOlxuXG5UaGFua3MgZm9yIGZpbGluZyFcblxuU3RhY2t0
-cmFjZTogX2F1dG8gcG9wdWxhdGVkIGJ5IG1pZ3JhdGlvbiBwcmV2aWV3IHRvb2wuX1xuXG5gYGBcbiIr
-SC5FaihjKSsiXG5gYGBcbiJdLG0sbSkpLmduRCgpKQptPXEuc3R5bGUKbS5kaXNwbGF5PSJpbml0aWFs
-IgpuPXIuc3R5bGUKbi5kaXNwbGF5PSJpbml0aWFsIgpuPWErIjogIitILkVqKGIpCndpbmRvdwppZih0
-eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3IobikKd2luZG93Cm49
-SC5FaihjKQppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3Io
-bil9LAp0MjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbz10LmcuYShXLnFjKGEuY3VycmVudFRh
-cmdldCkpCmEucHJldmVudERlZmF1bHQoKQpzPW8uZ2V0QXR0cmlidXRlKCJocmVmIikKcj1MLlVzKHMp
-CnE9TC5HNihzKQpwPUwuYUsocykKaWYocSE9bnVsbClMLmFmKHIscSxwLGIsbmV3IEwublQocixxLHAp
-KQplbHNlIEwuYWYocixudWxsLG51bGwsYixuZXcgTC5OWShyKSl9LApLMDpmdW5jdGlvbihhKXt2YXIg
-cyxyLHEscD1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIpCnAucXVlcnlTZWxlY3Rv
-cigiaDIiKS5pbm5lclRleHQ9IkZhaWxlZCB0byByZXJ1biBmcm9tIHNvdXJjZXMiCnAucXVlcnlTZWxl
-Y3RvcigicCIpLmlubmVyVGV4dD0iU291cmNlcyBjb250YWluIHN0YXRpYyBhbmFseXNpcyBlcnJvcnM6
-IgpzPXAucXVlcnlTZWxlY3RvcigicHJlIikKcj1KLkVsKGEsdC5hdykKcT1ILkxoKHIpCnMuaW5uZXJU
-ZXh0PW5ldyBILmxKKHIscS5DKCJxVSoobEQuRSkiKS5hKG5ldyBMLnVlKCkpLHEuQygibEo8bEQuRSxx
-VSo+IikpLmsoMCwiXG4iKQpxPXAucXVlcnlTZWxlY3RvcigiYS5ib3R0b20iKS5zdHlsZQpxLmRpc3Bs
-YXk9Im5vbmUiCnM9cC5zdHlsZQpzLmRpc3BsYXk9ImluaXRpYWwifSwKdlU6ZnVuY3Rpb24oKXt2YXIg
-cz1kb2N1bWVudApILkRoKHQuZyx0LmgsIlQiLCJxdWVyeVNlbGVjdG9yQWxsIikKcz1uZXcgVy53eihz
-LnF1ZXJ5U2VsZWN0b3JBbGwoIi5jb2RlIiksdC5SKQpzLksocyxuZXcgTC5lWCgpKX0sCmhYOmZ1bmN0
-aW9uKGEsYixjKXtyZXR1cm4gTC5ZdyhhLGIsYyl9LApZdzpmdW5jdGlvbihhLGIsYyl7dmFyIHM9MCxy
-PVAuRlgodC56KSxxPTEscCxvPVtdLG4sbSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJGhYPVAubHooZnVu
-Y3Rpb24oZCxlKXtpZihkPT09MSl7cD1lCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6cT0z
-Cmo9dC5YCnM9NgpyZXR1cm4gUC5qUShMLlE2KGEsUC5FRihbInJlZ2lvbiIsInJlZ2lvbiIsIm9mZnNl
-dCIsSC5FaihiKV0saixqKSx0LnQpLCRhc3luYyRoWCkKY2FzZSA2Om49ZQpqPW4KaT1KLlU2KGopCm09
-bmV3IFUuZDIoVS5qZihpLnEoaiwiZWRpdHMiKSksSC5oKGkucShqLCJleHBsYW5hdGlvbiIpKSxILnVQ
-KGkucShqLCJsaW5lIikpLEguaChpLnEoaiwiZGlzcGxheVBhdGgiKSksSC5oKGkucShqLCJ1cmlQYXRo
-IikpLFUuTmQoaS5xKGosInRyYWNlcyIpKSkKTC5UMShtKQpMLkZyKGEsYixjKQpMLnlYKCIuZWRpdC1w
-YW5lbCAucGFuZWwtY29udGVudCIsITEpCnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpnPXAKbD1ILlJ1
-KGcpCms9SC50cyhnKQpMLkMyKCJDb3VsZCBub3QgbG9hZCBlZGl0IGRldGFpbHMiLGwsaykKcz01CmJy
-ZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVy
-biBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJGhYLHIpfSwKRzc6ZnVuY3Rpb24oYSxiLGMs
-ZCxlKXtyZXR1cm4gTC5MNShhLGIsYyxkLGUpfSwKTDU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz0w
-LHI9UC5GWCh0LkgpLHEscD0yLG8sbj1bXSxtLGwsayxqLGksaCxnCnZhciAkYXN5bmMkRzc9UC5seihm
-dW5jdGlvbihmLGEwKXtpZihmPT09MSl7bz1hMApzPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAw
-OmlmKCFKLnA0KGEsIi5kYXJ0Iikpe0wuQkUoYSxCLndSKCksZCkKTC5CWChhLG51bGwpCmlmKGUhPW51
-bGwpZS4kMCgpCnM9MQpicmVha31wPTQKaT10LlgKcz03CnJldHVybiBQLmpRKEwuUTYoYSxQLkVGKFsi
-aW5saW5lIiwidHJ1ZSJdLGksaSksdC50KSwkYXN5bmMkRzcpCmNhc2UgNzptPWEwCkwuQkUoYSxCLllm
-KG0pLGQpCkwuZkcoYixjKQpsPUwuVXMoYSkKTC5CWChsLGIpCmlmKGUhPW51bGwpZS4kMCgpCnA9Mgpz
-PTYKYnJlYWsKY2FzZSA0OnA9MwpnPW8Kaz1ILlJ1KGcpCmo9SC50cyhnKQpMLkMyKCJDb3VsZCBub3Qg
-bG9hZCBkYXJ0IGZpbGUgIithLGssaikKcz02CmJyZWFrCmNhc2UgMzpzPTIKYnJlYWsKY2FzZSA2OmNh
-c2UgMTpyZXR1cm4gUC55QyhxLHIpCmNhc2UgMjpyZXR1cm4gUC5mMyhvLHIpfX0pCnJldHVybiBQLkRJ
-KCRhc3luYyRHNyxyKX0sCkdlOmZ1bmN0aW9uKCl7dmFyIHM9MCxyPVAuRlgodC56KSxxPTEscCxvPVtd
-LG4sbSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJEdlPVAubHooZnVuY3Rpb24oYSxiKXtpZihhPT09MSl7
-cD1iCnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6aD0iL19wcmV2aWV3L25hdmlnYXRpb25U
-cmVlLmpzb24iCnE9MwpzPTYKcmV0dXJuIFAualEoTC5RNihoLEMuQ00sdC5tKSwkYXN5bmMkR2UpCmNh
-c2UgNjpuPWIKbT1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIubmF2LXRyZWUiKQpKLmw1KG0sIiIpCmo9
-TC5tSyhuKQokLklSPWoKTC50WChtLGosITEpCnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpnPXAKbD1I
-LlJ1KGcpCms9SC50cyhnKQpMLkMyKCJDb3VsZCBub3QgbG9hZCBuYXZpZ2F0aW9uIHRyZWUiLGwsaykK
-cz01CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAx
-OnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJEdlLHIpfSwKcU86ZnVuY3Rpb24o
-YSl7dmFyIHMscj1hLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLHE9Qy5DRC56USgkLmZpKCkub2Zmc2V0
-SGVpZ2h0KSxwPXdpbmRvdy5pbm5lckhlaWdodCxvPUMuQ0QuelEoJC5EVygpLm9mZnNldEhlaWdodCkK
-aWYodHlwZW9mIHAhPT0ibnVtYmVyIilyZXR1cm4gcC5ITigpCnM9ci5ib3R0b20Kcy50b1N0cmluZwpp
-ZihzPnAtKG8rMTQpKUouZGgoYSkKZWxzZXtwPXIudG9wCnAudG9TdHJpbmcKaWYocDxxKzE0KUouZGgo
-YSl9fSwKZkc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCmlmKGEhPW51bGwpe3M9ZG9jdW1lbnQK
-cj1zLmdldEVsZW1lbnRCeUlkKCJvIitILkVqKGEpKQpxPXMucXVlcnlTZWxlY3RvcigiLmxpbmUtIitI
-LkVqKGIpKQppZihyIT1udWxsKXtMLnFPKHIpCkouZFIocikuaSgwLCJ0YXJnZXQiKX1lbHNlIGlmKHEh
-PW51bGwpTC5xTyhxLnBhcmVudEVsZW1lbnQpCmlmKHEhPW51bGwpSi5kUih0LmcuYShxLnBhcmVudE5v
-ZGUpKS5pKDAsImhpZ2hsaWdodCIpfWVsc2V7cz1kb2N1bWVudApwPXQuZwpILkRoKHAsdC5oLCJUIiwi
-cXVlcnlTZWxlY3RvckFsbCIpCnM9cy5xdWVyeVNlbGVjdG9yQWxsKCIubGluZS1ubyIpCm89bmV3IFcu
-d3oocyx0LlIpCmlmKG8uZ0Eobyk9PT0wKXJldHVybgpMLnFPKHAuYShDLnQ1Lmd0SChzKSkpfX0sCmFm
-OmZ1bmN0aW9uKGEsYixjLGQsZSl7dmFyIHMscixxPUwuRzYod2luZG93LmxvY2F0aW9uLmhyZWYpLHA9
-TC5hSyh3aW5kb3cubG9jYXRpb24uaHJlZikKaWYocSE9bnVsbCl7cz1kb2N1bWVudC5nZXRFbGVtZW50
-QnlJZCgibyIrSC5FaihxKSkKaWYocyE9bnVsbClKLmRSKHMpLkwoMCwidGFyZ2V0Iil9aWYocCE9bnVs
-bCl7cj1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIubGluZS0iK0guRWoocCkpCmlmKHIhPW51bGwpSi5k
-UihyLnBhcmVudEVsZW1lbnQpLkwoMCwiaGlnaGxpZ2h0Iil9aWYoYT09d2luZG93LmxvY2F0aW9uLnBh
-dGhuYW1lKXtMLmZHKGIsYykKZS4kMCgpfWVsc2UgTC5HNyhhLGIsYyxkLGUpfSwKUTQ6ZnVuY3Rpb24o
-YSxiKXt2YXIgcyxyLHE9UC5oSyhhKSxwPXQuWApwPVAuRmwocCxwKQpmb3Iocz1xLmdoWSgpLHM9cy5n
-UHUocykscz1zLmdtKHMpO3MuRigpOyl7cj1zLmdsKCkKcC5ZNSgwLHIuYSxyLmIpfWZvcihzPWIuZ1B1
-KGIpLHM9cy5nbShzKTtzLkYoKTspe3I9cy5nbCgpCnAuWTUoMCxyLmEsci5iKX1wLlk1KDAsImF1dGhU
-b2tlbiIsJC5VRSgpKQpyZXR1cm4gcS5ubSgwLHApLmduRCgpfSwKVDE6ZnVuY3Rpb24oYSl7dmFyIHMs
-cixxLHAsbyxuLG0sbCxrLGo9JC5oTCgpCkoubDUoaiwiIikKaWYoYT09bnVsbCl7cz1kb2N1bWVudC5j
-cmVhdGVFbGVtZW50KCJwIikKQy5MdC5zYTQocywiU2VlIGRldGFpbHMgYWJvdXQgYSBwcm9wb3NlZCBl
-ZGl0LiIpCkMuTHQuc24ocyxILlZNKFsicGxhY2Vob2xkZXIiXSx0LmkpKQpqLmFwcGVuZENoaWxkKHMp
-CkMuTHQuRkYocykKcmV0dXJufXI9YS5kCnE9JC5uVSgpCnA9cS56ZihyKQpvPWEuYgpuPWRvY3VtZW50
-Cm09cS5IUChyLEouVDAobi5xdWVyeVNlbGVjdG9yKCIucm9vdCIpLnRleHRDb250ZW50KSkKbD1hLmMK
-az1uLmNyZWF0ZUVsZW1lbnQoInAiKQpqLmFwcGVuZENoaWxkKGspCmsuYXBwZW5kQ2hpbGQobi5jcmVh
-dGVUZXh0Tm9kZShILkVqKG8pKyIgYXQgIikpCnE9dC5YCnE9Vy5KNihMLlE0KGEuZSxQLkVGKFsibGlu
-ZSIsSi5qKGwpXSxxLHEpKSkKcS5hcHBlbmRDaGlsZChuLmNyZWF0ZVRleHROb2RlKEguRWoobSkrIjoi
-K0guRWoobCkrIi4iKSkKay5hcHBlbmRDaGlsZChxKQpKLmRoKGspCkwuQ0MoYSxqLHApCkwuRnooYSxq
-KX0sCkxIOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGU9JC55
-UCgpCkoubDUoZSwiIikKaWYoYi5nQShiKT09PTApe3M9ZG9jdW1lbnQKcj1zLmNyZWF0ZUVsZW1lbnQo
-InAiKQplLmFwcGVuZENoaWxkKHIpCnIuYXBwZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZSgiTm8gcHJv
-cG9zZWQgZWRpdHMiKSl9ZWxzZSBmb3IoZT1iLmdQdShiKSxlPWUuZ20oZSkscz10LlgscT10LmsscD1x
-LkMoIn4oMSk/Iiksbz10LloscT1xLmM7ZS5GKCk7KXtuPWUuZ2woKQptPWRvY3VtZW50CnI9bS5jcmVh
-dGVFbGVtZW50KCJwIikKbD0kLnlQKCkKbC5hcHBlbmRDaGlsZChyKQpyLmFwcGVuZENoaWxkKG0uY3Jl
-YXRlVGV4dE5vZGUoSC5FaihuLmEpKyI6IikpCms9bS5jcmVhdGVFbGVtZW50KCJ1bCIpCmwuYXBwZW5k
-Q2hpbGQoaykKZm9yKG49Si5JVChuLmIpO24uRigpOyl7bD1uLmdsKCkKaj1tLmNyZWF0ZUVsZW1lbnQo
-ImxpIikKay5hcHBlbmRDaGlsZChqKQpKLmRSKGopLmkoMCwiZWRpdCIpCmk9bS5jcmVhdGVFbGVtZW50
-KCJhIikKai5hcHBlbmRDaGlsZChpKQppLmNsYXNzTGlzdC5hZGQoImVkaXQtbGluayIpCmg9bC5jCmc9
-SC5FaihoKQppLnNldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KGkpKS5QKCJvZmZz
-ZXQiKSxnKQpmPWwuYQpnPUguRWooZikKaS5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcg
-Vy5pNyhpKSkuUCgibGluZSIpLGcpCmkuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgibGluZSAi
-K0guRWooZikpKQppLnNldEF0dHJpYnV0ZSgiaHJlZiIsTC5RNCh3aW5kb3cubG9jYXRpb24ucGF0aG5h
-bWUsUC5FRihbImxpbmUiLEguRWooZiksIm9mZnNldCIsSC5FaihoKV0scyxzKSkpCmc9cC5hKG5ldyBM
-LkVFKGgsZixhKSkKby5hKG51bGwpClcuSkUoaSwiY2xpY2siLGcsITEscSkKai5hcHBlbmRDaGlsZCht
-LmNyZWF0ZVRleHROb2RlKCI6ICIrSC5FaihsLmIpKSl9fWlmKGMpTC5UMShudWxsKX0sCkZyOmZ1bmN0
-aW9uKGEsYixjKXt2YXIgcyxyLHE9d2luZG93LmxvY2F0aW9uLHA9UC5oSygocSYmQy5FeCkuZ0RyKHEp
-K0guRWooYSkpCnE9dC5YCnE9UC5GbChxLHEpCmlmKGIhPW51bGwpcS5ZNSgwLCJvZmZzZXQiLEguRWoo
-YikpCmlmKGMhPW51bGwpcS5ZNSgwLCJsaW5lIixILkVqKGMpKQpxLlk1KDAsImF1dGhUb2tlbiIsJC5V
-RSgpKQpwPXAubm0oMCxxKQpxPXdpbmRvdy5oaXN0b3J5CnM9dC56CnI9cC5nbkQoKQpxLnRvU3RyaW5n
-CnEucHVzaFN0YXRlKG5ldyBQLkJmKFtdLFtdKS5QdihQLkZsKHMscykpLCIiLHIpfSwKRW46ZnVuY3Rp
-b24oYSl7dmFyIHM9Si5iYihkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucm9vdCIpLnRleHRDb250ZW50
-LCIvIikKaWYoQy54Qi5uQyhhLHMpKXJldHVybiBDLnhCLnluKGEscy5sZW5ndGgpCmVsc2UgcmV0dXJu
-IGF9LApPdDpmdW5jdGlvbihhKXtzd2l0Y2goYS5yKXtjYXNlIEMuY3c6YnJlYWsKY2FzZSBDLldEOmEu
-cj1DLlhqCmJyZWFrCmNhc2UgQy5YajphLnI9Qy5XRApicmVhawpjYXNlIEMuZGM6dGhyb3cgSC5iKFAu
-UFYoIkZpbGUgIitILkVqKGEuYykrIiBzaG91bGQgbm90IGhhdmUgaW5kZXRlcm1pbmF0ZSBtaWdyYXRp
-b24gc3RhdHVzIikpfX0sCnhuOmZ1bmN0aW9uKGEsYil7TC50YShhLGIuZ2Q2KCkpCmlmKGIuYz09JC5E
-OSgpLmlubmVyVGV4dClMLnRhKCQuYzAoKSxiLmdkNigpKX0sCnRhOmZ1bmN0aW9uKGEsYil7dmFyIHMs
-cj0iY2hlY2tfYm94IixxPSJ0aXRsZSIscD0ib3B0ZWQtb3V0IixvPSJtaWdyYXRpbmciCnN3aXRjaChi
-KXtjYXNlIEMuY3c6YS5pbm5lclRleHQ9cgpKLmRSKGEpLmkoMCwiYWxyZWFkeS1taWdyYXRlZCIpCmEu
-c2V0QXR0cmlidXRlKHEsIkFscmVhZHkgbWlncmF0ZWQiKQpicmVhawpjYXNlIEMuV0Q6YS5pbm5lclRl
-eHQ9cgpzPUouWUUoYSkKcy5nbihhKS5MKDAscCkKcy5nbihhKS5pKDAsbykKYS5zZXRBdHRyaWJ1dGUo
-cSwiTWlncmF0aW5nIHRvIG51bGwgc2FmZXR5IikKYnJlYWsKY2FzZSBDLlhqOmEuaW5uZXJUZXh0PSJj
-aGVja19ib3hfb3V0bGluZV9ibGFuayIKcz1KLllFKGEpCnMuZ24oYSkuTCgwLG8pCnMuZ24oYSkuaSgw
-LHApCmEuc2V0QXR0cmlidXRlKHEsIk9wdGluZyBvdXQgb2YgbnVsbCBzYWZldHkiKQpicmVhawpkZWZh
-dWx0OmEuaW5uZXJUZXh0PSJpbmRldGVybWluYXRlX2NoZWNrX2JveCIKcz1KLllFKGEpCnMuZ24oYSku
-TCgwLG8pCnMuZ24oYSkuaSgwLHApCmEuc2V0QXR0cmlidXRlKHEsIk1peGVkIHN0YXR1c2VzIG9mICdt
-aWdyYXRpbmcnIGFuZCAnb3B0aW5nIG91dCciKQpicmVha319LApCWDpmdW5jdGlvbihhLGIpe3ZhciBz
-LHI9e30Kci5hPWEKYT1MLkVuKGEpCnIuYT1hCkouZHIoJC5EOSgpLGEpCnM9ZG9jdW1lbnQKSC5EaCh0
-LmcsdC5oLCJUIiwicXVlcnlTZWxlY3RvckFsbCIpCnM9bmV3IFcud3oocy5xdWVyeVNlbGVjdG9yQWxs
-KCIubmF2LXBhbmVsIC5uYXYtbGluayIpLHQuUikKcy5LKHMsbmV3IEwuVlMocikpCkouZFIoJC5iTigp
-KS5pKDAsInZpc2libGUiKX0sCkFSOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWIuYgppZihxIT1udWxs
-KXtzPXQuZwpyPXMuYShzLmEoYS5wYXJlbnROb2RlKS5wYXJlbnROb2RlKQpMLnhuKHIucXVlcnlTZWxl
-Y3RvcigiOnNjb3BlID4gLnN0YXR1cy1pY29uIikscSkKTC5BUihyLHEpfX0sCkJFOmZ1bmN0aW9uKGEs
-YixjKXt2YXIgcz0iLnJlZ2lvbnMiLHI9ZG9jdW1lbnQscT1yLnF1ZXJ5U2VsZWN0b3IocykscD1yLnF1
-ZXJ5U2VsZWN0b3IoIi5jb2RlIikKSi50SChxLGIuYSwkLktHKCkpCkoudEgocCxiLmIsJC5LRygpKQpM
-LkxIKGEsYi5kLGMpCmlmKGIuYy5sZW5ndGg8MmU1KUwudlUoKQpMLnlYKCIuY29kZSIsITApCkwueVgo
-cywhMCl9LAp0WDpmdW5jdGlvbihhLGIsYTApe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGksaCxnLGYs
-ZT0ibWF0ZXJpYWwtaWNvbnMiLGQ9ZG9jdW1lbnQsYz1kLmNyZWF0ZUVsZW1lbnQoInVsIikKYS5hcHBl
-bmRDaGlsZChjKQpmb3Iocz1iLmxlbmd0aCxyPXQuWCxxPXQuWixwPTA7cDxiLmxlbmd0aDtiLmxlbmd0
-aD09PXN8fCgwLEgubGspKGIpLCsrcCl7bz1iW3BdCm49ZC5jcmVhdGVFbGVtZW50KCJsaSIpCmMuYXBw
-ZW5kQ2hpbGQobikKaWYobyBpbnN0YW5jZW9mIEwudnQpe0ouZFIobikuaSgwLCJkaXIiKQpuLnNldEF0
-dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KG4pKS5QKCJuYW1lIiksby5jKQptPWQuY3Jl
-YXRlRWxlbWVudCgic3BhbiIpCm4uYXBwZW5kQ2hpbGQobSkKbD1KLllFKG0pCmwuZ24obSkuaSgwLCJh
-cnJvdyIpCmwuc2hmKG0sIiYjeDI1QkM7IikKaz1kLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpKLmRSKGsp
-LmkoMCxlKQprLmlubmVyVGV4dD0iZm9sZGVyX29wZW4iCm4uYXBwZW5kQ2hpbGQoaykKbi5hcHBlbmRD
-aGlsZChkLmNyZWF0ZVRleHROb2RlKG8uYSkpCkwudFgobixvLmQsITEpCkwua3oobSl9ZWxzZSBpZihv
-IGluc3RhbmNlb2YgTC5jRCl7bD1kLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpKLmRSKGwpLmkoMCxlKQps
-LmlubmVyVGV4dD0iaW5zZXJ0X2RyaXZlX2ZpbGUiCm4uYXBwZW5kQ2hpbGQobCkKaj1kLmNyZWF0ZUVs
-ZW1lbnQoImEiKQpuLmFwcGVuZENoaWxkKGopCmw9Si5ZRShqKQpsLmduKGopLmkoMCwibmF2LWxpbmsi
-KQpqLnNldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KGopKS5QKCJuYW1lIiksby5j
-KQpqLnNldEF0dHJpYnV0ZSgiaHJlZiIsTC5RNChvLmQsUC5GbChyLHIpKSkKai5hcHBlbmRDaGlsZChk
-LmNyZWF0ZVRleHROb2RlKG8uYSkpCmw9bC5nVmwoaikKaT1sLiR0aQpoPWkuQygifigxKT8iKS5hKG5l
-dyBMLlREKCkpCnEuYShudWxsKQpXLkpFKGwuYSxsLmIsaCwhMSxpLmMpCmc9by5lCmlmKHR5cGVvZiBn
-IT09Im51bWJlciIpcmV0dXJuIGcub3MoKQppZihnPjApe2Y9ZC5jcmVhdGVFbGVtZW50KCJzcGFuIikK
-bi5hcHBlbmRDaGlsZChmKQpKLmRSKGYpLmkoMCwiZWRpdC1jb3VudCIpCmw9IiIrZysiICIKaWYoZz09
-PTEpaT0icHJvcG9zZWQgZWRpdCIKZWxzZSBpPSJwcm9wb3NlZCBlZGl0cyIKZi5zZXRBdHRyaWJ1dGUo
-InRpdGxlIixsK2kpCmYuYXBwZW5kQ2hpbGQoZC5jcmVhdGVUZXh0Tm9kZShDLmpuLncoZykpKX19fX0s
-CnV6OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1kb2N1bWVudCxyPXMuY3JlYXRlRWxlbWVudCgiYnV0dG9u
-IikscT10LmsscD1xLkMoIn4oMSk/IikuYShuZXcgTC5tMihhLGMpKQp0LlouYShudWxsKQpXLkpFKHIs
-ImNsaWNrIixwLCExLHEuYykKci5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKE0uT1goYS5hKSkp
-CmIuYXBwZW5kQ2hpbGQocil9LApGejpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxq
-LGksaD1hLmEKaWYoaD09bnVsbClyZXR1cm4Kcz1kb2N1bWVudApyPXMuY3JlYXRlRWxlbWVudCgicCIp
-CnE9Yi5hcHBlbmRDaGlsZChyKQpyPXMuY3JlYXRlRWxlbWVudCgic3BhbiIpCnA9dC5pCkouTXUocixI
-LlZNKFsidHlwZS1kZXNjcmlwdGlvbiJdLHApKQpyLmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUo
-IkFjdGlvbnMiKSkKcS5hcHBlbmRDaGlsZChyKQpxLmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUo
-IjoiKSkKbz1zLmNyZWF0ZUVsZW1lbnQoInAiKQpiLmFwcGVuZENoaWxkKG8pCmZvcihyPWgubGVuZ3Ro
-LG49dC5RLG09MDttPGgubGVuZ3RoO2gubGVuZ3RoPT09cnx8KDAsSC5saykoaCksKyttKXtsPWhbbV0K
-az1zLmNyZWF0ZUVsZW1lbnQoImEiKQpvLmFwcGVuZENoaWxkKGspCmsuYXBwZW5kQ2hpbGQocy5jcmVh
-dGVUZXh0Tm9kZShsLmEpKQprLnNldEF0dHJpYnV0ZSgiaHJlZiIsbC5iKQpqPW4uYShILlZNKFsiYWRk
-LWhpbnQtbGluayIsImJlZm9yZS1hcHBseSIsImJ1dHRvbiJdLHApKQppPUouZFIoaykKaS5WMSgwKQpp
-LkZWKDAsail9fSwKQ0M6ZnVuY3Rpb24oYTQsYTUsYTYpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqLGks
-aCxnLGYsZSxkLGMsYixhLGEwLGExLGEyLGEzCmZvcihzPWE0LmYscj1zLmxlbmd0aCxxPXQuaSxwPXQu
-USxvPTA7bzxzLmxlbmd0aDtzLmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsrbyl7bj1zW29dCm09ZG9j
-dW1lbnQKbD1tLmNyZWF0ZUVsZW1lbnQoInAiKQprPXAuYShILlZNKFsidHJhY2UiXSxxKSkKaj1KLmRS
-KGwpCmouVjEoMCkKai5GVigwLGspCmk9YTUuYXBwZW5kQ2hpbGQobCkKbD1tLmNyZWF0ZUVsZW1lbnQo
-InNwYW4iKQprPXAuYShILlZNKFsidHlwZS1kZXNjcmlwdGlvbiJdLHEpKQpqPUouZFIobCkKai5WMSgw
-KQpqLkZWKDAsaykKbC5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKG4uYSkpCmkuYXBwZW5kQ2hp
-bGQobCkKaS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKCI6IikpCmw9bS5jcmVhdGVFbGVtZW50
-KCJ1bCIpCms9cC5hKEguVk0oWyJ0cmFjZSJdLHEpKQpqPUouZFIobCkKai5WMSgwKQpqLkZWKDAsaykK
-aD1pLmFwcGVuZENoaWxkKGwpCmZvcihsPW4uYixrPWwubGVuZ3RoLGc9MDtnPGwubGVuZ3RoO2wubGVu
-Z3RoPT09a3x8KDAsSC5saykobCksKytnKXtmPWxbZ10KZT1tLmNyZWF0ZUVsZW1lbnQoImxpIikKaC5h
-cHBlbmRDaGlsZChlKQpkPW0uY3JlYXRlRWxlbWVudCgic3BhbiIpCmM9cC5hKEguVk0oWyJmdW5jdGlv
-biJdLHEpKQpqPUouZFIoZCkKai5WMSgwKQpqLkZWKDAsYykKYz1mLmIKTC5rRChkLGM9PW51bGw/InVu
-a25vd24iOmMpCmUuYXBwZW5kQ2hpbGQoZCkKYj1mLmMKaWYoYiE9bnVsbCl7ZS5hcHBlbmRDaGlsZCht
-LmNyZWF0ZVRleHROb2RlKCIgKCIpKQphPWIuYgphMD1tLmNyZWF0ZUVsZW1lbnQoImEiKQphMC5hcHBl
-bmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKEguRWooYi5jKSsiOiIrSC5FaihhKSkpCmEwLnNldEF0dHJp
-YnV0ZSgiaHJlZiIsYi5hKQphMC5jbGFzc0xpc3QuYWRkKCJuYXYtbGluayIpCmUuYXBwZW5kQ2hpbGQo
-YTApCmUuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiKSIpKX1lLmFwcGVuZENoaWxkKG0uY3Jl
-YXRlVGV4dE5vZGUoIjogIikpCmQ9Zi5hCkwua0QoZSxkPT1udWxsPyJ1bmtub3duIjpkKQpkPWYuZApp
-ZihkLmxlbmd0aCE9PTApe2M9bS5jcmVhdGVFbGVtZW50KCJwIikKYTE9cC5hKEguVk0oWyJkcmF3ZXIi
-LCJiZWZvcmUtYXBwbHkiXSxxKSkKaj1KLmRSKGMpCmouVjEoMCkKai5GVigwLGExKQphMj1lLmFwcGVu
-ZENoaWxkKGMpCmZvcihjPWQubGVuZ3RoLGEzPTA7YTM8ZC5sZW5ndGg7ZC5sZW5ndGg9PT1jfHwoMCxI
-LmxrKShkKSwrK2EzKUwudXooZFthM10sYTIsYil9fX19LApVczpmdW5jdGlvbihhKXtyZXR1cm4gSi5V
-NihhKS50ZyhhLCI/Iik/Qy54Qi5OaihhLDAsQy54Qi5PWShhLCI/IikpOmF9LAprRDpmdW5jdGlvbihh
-LGIpe3ZhciBzLHIscT1ILlZNKGIuc3BsaXQoIi4iKSx0LnMpLHA9Qy5ObS5ndEgocSksbz1kb2N1bWVu
-dAphLmFwcGVuZENoaWxkKG8uY3JlYXRlVGV4dE5vZGUocCkpCmZvcihwPUgucUMocSwxLG51bGwsdC5O
-KSxwPW5ldyBILmE3KHAscC5nQShwKSxwLiR0aS5DKCJhNzxhTC5FPiIpKSxzPUouWUUoYSk7cC5GKCk7
-KXtyPXAuZApzLm56KGEsImJlZm9yZWVuZCIsIiYjODIwMzsuIixudWxsLG51bGwpCmEuYXBwZW5kQ2hp
-bGQoby5jcmVhdGVUZXh0Tm9kZShyKSl9fSwKbUg6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscApmb3Io
-cz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDthLmxlbmd0aD09PXN8fCgwLEgubGspKGEpLCsrcil7cT1h
-W3JdCmlmKHEgaW5zdGFuY2VvZiBMLnZ0KXtwPUwubUgocS5kLGIpCmlmKHAhPW51bGwpcmV0dXJuIHB9
-ZWxzZSBpZihxLmM9PWIpcmV0dXJuIHF9cmV0dXJuIG51bGx9LAplOmZ1bmN0aW9uIGUoKXt9LApWVzpm
-dW5jdGlvbiBWVyhhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApvWjpmdW5jdGlvbiBv
-Wigpe30sCmpyOmZ1bmN0aW9uIGpyKCl7fSwKcWw6ZnVuY3Rpb24gcWwoKXt9LApIaTpmdW5jdGlvbiBI
-aSgpe30sCkJUOmZ1bmN0aW9uIEJUKCl7fSwKUFk6ZnVuY3Rpb24gUFkoKXt9LAp1ODpmdW5jdGlvbiB1
-OCgpe30sCkw6ZnVuY3Rpb24gTCgpe30sCld4OmZ1bmN0aW9uIFd4KGEsYil7dGhpcy5hPWEKdGhpcy5i
-PWJ9LApBTzpmdW5jdGlvbiBBTyhhKXt0aGlzLmE9YX0sCmROOmZ1bmN0aW9uIGROKGEpe3RoaXMuYT1h
-fSwKSG86ZnVuY3Rpb24gSG8oYSl7dGhpcy5hPWF9LAp4ejpmdW5jdGlvbiB4eihhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKSUM6ZnVuY3Rpb24gSUMoKXt9LApmQzpmdW5jdGlvbiBmQyhhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKblQ6ZnVuY3Rpb24gblQoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1j
-fSwKTlk6ZnVuY3Rpb24gTlkoYSl7dGhpcy5hPWF9LAp1ZTpmdW5jdGlvbiB1ZSgpe30sCmVYOmZ1bmN0
-aW9uIGVYKCl7fSwKRUU6ZnVuY3Rpb24gRUUoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1j
-fSwKUUw6ZnVuY3Rpb24gUUwoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sClZTOmZ1bmN0aW9uIFZTKGEp
-e3RoaXMuYT1hfSwKVEQ6ZnVuY3Rpb24gVEQoKXt9LAptMjpmdW5jdGlvbiBtMihhLGIpe3RoaXMuYT1h
-CnRoaXMuYj1ifSwKWEE6ZnVuY3Rpb24gWEEoKXt9LApaczpmdW5jdGlvbihhKXt2YXIgcyxyLHE9Si5V
-NihhKQppZihMLnAyKEguaChxLnEoYSwidHlwZSIpKSk9PT1DLlkyKXtzPUguaChxLnEoYSwibmFtZSIp
-KQpyPUguaChxLnEoYSwicGF0aCIpKQpxPXEucShhLCJzdWJ0cmVlIikKcT1uZXcgTC52dChxPT1udWxs
-P251bGw6TC5tSyhxKSxzLHIpCnEuTFYoKQpyZXR1cm4gcX1lbHNle3M9SC5oKHEucShhLCJuYW1lIikp
-CnI9SC5oKHEucShhLCJwYXRoIikpCnJldHVybiBuZXcgTC5jRChILmgocS5xKGEsImhyZWYiKSksSC51
-UChxLnEoYSwiZWRpdENvdW50IikpLEgueTgocS5xKGEsIndhc0V4cGxpY2l0bHlPcHRlZE91dCIpKSxM
-LnZCKEgudVAocS5xKGEsIm1pZ3JhdGlvblN0YXR1cyIpKSkscyxyKX19LAptSzpmdW5jdGlvbihhKXt2
-YXIgcyxyPUguVk0oW10sdC5jUSkKZm9yKHM9Si5JVCh0LlUuYShhKSk7cy5GKCk7KXIucHVzaChMLlpz
-KHMuZ2woKSkpCnJldHVybiByfSwKVkQ6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUguVk0oW10sdC5HKQpm
-b3Iocz1hLmxlbmd0aCxyPTA7cjxhLmxlbmd0aDthLmxlbmd0aD09PXN8fCgwLEgubGspKGEpLCsrcilx
-LnB1c2goYVtyXS5MdCgpKQpyZXR1cm4gcX0sCnZCOmZ1bmN0aW9uKGEpe2lmKGE9PW51bGwpcmV0dXJu
-IG51bGwKaWYoYT4+PjAhPT1hfHxhPj00KXJldHVybiBILk9IKEMubDAsYSkKcmV0dXJuIEMubDBbYV19
-LApwMjpmdW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSJkaXJlY3RvcnkiOnJldHVybiBDLlkyCmNhc2Ui
-ZmlsZSI6cmV0dXJuIEMucmYKZGVmYXVsdDp0aHJvdyBILmIoUC5QVigiVW5yZWNvZ25pemVkIG5hdmln
-YXRpb24gdHJlZSBub2RlIHR5cGU6ICIrSC5FaihhKSkpfX0sCnZ0OmZ1bmN0aW9uIHZ0KGEsYixjKXt2
-YXIgXz10aGlzCl8uZD1hCl8uYT1iCl8uYj1udWxsCl8uYz1jfSwKY0Q6ZnVuY3Rpb24gY0QoYSxiLGMs
-ZCxlLGYpe3ZhciBfPXRoaXMKXy5kPWEKXy5lPWIKXy5mPWMKXy5yPWQKXy5hPWUKXy5iPW51bGwKXy5j
-PWZ9LApEODpmdW5jdGlvbiBEOCgpe30sCk85OmZ1bmN0aW9uIE85KGEpe3RoaXMuYj1hfSwKR2I6ZnVu
-Y3Rpb24gR2IoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCklWOmZ1bmN0aW9uIElWKGEsYixjLGQpe3Zh
-ciBfPXRoaXMKXy5kPWEKXy5lPWIKXy5mPWMKXy5yPWR9fSxYPXsKQ0w6ZnVuY3Rpb24oYSxiKXt2YXIg
-cyxyLHEscCxvLG49Yi54WihhKQpiLmhLKGEpCmlmKG4hPW51bGwpYT1KLktWKGEsbi5sZW5ndGgpCnM9
-dC5zCnI9SC5WTShbXSxzKQpxPUguVk0oW10scykKcz1hLmxlbmd0aAppZihzIT09MCYmYi5yNChDLnhC
-LlcoYSwwKSkpe2lmKDA+PXMpcmV0dXJuIEguT0goYSwwKQpDLk5tLmkocSxhWzBdKQpwPTF9ZWxzZXtD
-Lk5tLmkocSwiIikKcD0wfWZvcihvPXA7bzxzOysrbylpZihiLnI0KEMueEIuVyhhLG8pKSl7Qy5ObS5p
-KHIsQy54Qi5OaihhLHAsbykpCkMuTm0uaShxLGFbb10pCnA9bysxfWlmKHA8cyl7Qy5ObS5pKHIsQy54
-Qi55bihhLHApKQpDLk5tLmkocSwiIil9cmV0dXJuIG5ldyBYLldEKGIsbixyLHEpfSwKV0Q6ZnVuY3Rp
-b24gV0QoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9YwpfLmU9ZH0sCkk3OmZ1bmN0
-aW9uKGEpe3JldHVybiBuZXcgWC5kdihhKX0sCmR2OmZ1bmN0aW9uIGR2KGEpe3RoaXMuYT1hfX0sTz17
-ClJoOmZ1bmN0aW9uKCl7dmFyIHMscj1udWxsCmlmKFAudW8oKS5nRmkoKSE9PSJmaWxlIilyZXR1cm4g
-JC5FYigpCnM9UC51bygpCmlmKCFDLnhCLlRjKHMuZ0lpKHMpLCIvIikpcmV0dXJuICQuRWIoKQppZihQ
-LktMKHIsImEvYiIscixyLHIscixyKS50NCgpPT09ImFcXGIiKXJldHVybiAkLktrKCkKcmV0dXJuICQu
-YkQoKX0sCnpMOmZ1bmN0aW9uIHpMKCl7fX0sRT17T0Y6ZnVuY3Rpb24gT0YoYSxiLGMpe3RoaXMuZD1h
-CnRoaXMuZT1iCnRoaXMuZj1jfX0sRj17cnU6ZnVuY3Rpb24gcnUoYSxiLGMsZCl7dmFyIF89dGhpcwpf
-LmQ9YQpfLmU9YgpfLmY9YwpfLnI9ZH19LEQ9ewphYjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89bnVs
-bAp0cnl7bz1QLnVvKCl9Y2F0Y2gocyl7aWYodC5nOC5iKEguUnUocykpKXtyPSQuRmYKaWYociE9bnVs
-bClyZXR1cm4gcgp0aHJvdyBzfWVsc2UgdGhyb3cgc31pZihKLlJNKG8sJC5JNikpe3I9JC5GZgpyLnRv
-U3RyaW5nCnJldHVybiByfSQuSTY9bwppZigkLkhrKCk9PSQuRWIoKSlyPSQuRmY9by5aSSgiLiIpLnco
-MCkKZWxzZXtxPW8udDQoKQpwPXEubGVuZ3RoLTEKcj0kLkZmPXA9PT0wP3E6Qy54Qi5OaihxLDAscCl9
-ci50b1N0cmluZwpyZXR1cm4gcn19CnZhciB3PVtDLEgsSixQLFcsTSxVLEIsVCxMLFgsTyxFLEYsRF0K
-aHVua0hlbHBlcnMuc2V0RnVuY3Rpb25OYW1lc0lmTmVjZXNzYXJ5KHcpCnZhciAkPXt9CkguRksucHJv
-dG90eXBlPXt9CkouR3YucHJvdG90eXBlPXsKRE46ZnVuY3Rpb24oYSxiKXtyZXR1cm4gYT09PWJ9LApn
-aU86ZnVuY3Rpb24oYSl7cmV0dXJuIEguZVEoYSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiJJbnN0YW5j
-ZSBvZiAnIitILkVqKEguTShhKSkrIicifSwKZTc6ZnVuY3Rpb24oYSxiKXt0Lm8uYShiKQp0aHJvdyBI
-LmIoUC5scihhLGIuZ1dhKCksYi5nbmQoKSxiLmdWbSgpKSl9fQpKLnlFLnByb3RvdHlwZT17Cnc6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gYT81MTkwMTg6
-MjE4MTU5fSwKJGlhMjoxfQpKLndlLnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51
-bGw9PWJ9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiJudWxsIn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4g
-MH0sCmU3OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuU2ooYSx0Lm8uYShiKSl9LAokaWM4OjF9Ckou
-TUYucHJvdG90eXBlPXsKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiAwfSwKdzpmdW5jdGlvbihhKXtyZXR1
-cm4gU3RyaW5nKGEpfSwKJGl2bToxfQpKLmlDLnByb3RvdHlwZT17fQpKLmtkLnByb3RvdHlwZT17fQpK
-LmM1LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9YVskLncoKV0KaWYocz09bnVsbClyZXR1
-cm4gdGhpcy50KGEpCnJldHVybiJKYXZhU2NyaXB0IGZ1bmN0aW9uIGZvciAiK0guRWooSi5qKHMpKX0s
-CiRpRUg6MX0KSi5qZC5wcm90b3R5cGU9ewpkcjpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgSC5qVihh
-LEgudDYoYSkuQygiQDwxPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9LAppOmZ1bmN0aW9uKGEsYil7SC50
-NihhKS5jLmEoYikKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiYWRkIikpCmEucHVzaChiKX0s
-Clc0OmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgicmVtb3Zl
-QXQiKSkKcz1hLmxlbmd0aAppZihiPj1zKXRocm93IEguYihQLk83KGIsbnVsbCkpCnJldHVybiBhLnNw
-bGljZShiLDEpWzBdfSwKVUc6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKSC50NihhKS5DKCJjWDwxPiIp
-LmEoYykKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiaW5zZXJ0QWxsIikpClAud0EoYiwwLGEu
-bGVuZ3RoLCJpbmRleCIpCmlmKCF0LmIuYihjKSljPUouUlgoYykKcz1KLkhtKGMpCmEubGVuZ3RoPWEu
-bGVuZ3RoK3MKcj1iK3MKdGhpcy5ZVyhhLHIsYS5sZW5ndGgsYSxiKQp0aGlzLnZnKGEsYixyLGMpfSwK
-RlY6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnQ2KGEpLkMoImNYPDE+IikuYShiKQppZighIWEuZml4ZWQk
-bGVuZ3RoKUgudihQLkw0KCJhZGRBbGwiKSkKZm9yKHM9Si5JVChiKTtzLkYoKTspYS5wdXNoKHMuZ2wo
-KSl9LApFMjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC50NihhKQpyZXR1cm4gbmV3IEgubEooYSxzLktx
-KGMpLkMoIjEoMikiKS5hKGIpLHMuQygiQDwxPiIpLktxKGMpLkMoImxKPDEsMj4iKSl9LAprOmZ1bmN0
-aW9uKGEsYil7dmFyIHMscj1QLk84KGEubGVuZ3RoLCIiLCExLHQuTikKZm9yKHM9MDtzPGEubGVuZ3Ro
-Oysrcyl0aGlzLlk1KHIscyxILkVqKGFbc10pKQpyZXR1cm4gci5qb2luKGIpfSwKZVI6ZnVuY3Rpb24o
-YSxiKXtyZXR1cm4gSC5xQyhhLGIsbnVsbCxILnQ2KGEpLmMpfSwKTjA6ZnVuY3Rpb24oYSxiLGMsZCl7
-dmFyIHMscixxCmQuYShiKQpILnQ2KGEpLktxKGQpLkMoIjEoMSwyKSIpLmEoYykKcz1hLmxlbmd0aApm
-b3Iocj1iLHE9MDtxPHM7KytxKXtyPWMuJDIocixhW3FdKQppZihhLmxlbmd0aCE9PXMpdGhyb3cgSC5i
-KFAuYTQoYSkpfXJldHVybiByfSwKSHQ6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCkgudDYoYSku
-QygiYTIoMSkiKS5hKGIpCnM9YS5sZW5ndGgKZm9yKHI9bnVsbCxxPSExLHA9MDtwPHM7KytwKXtvPWFb
-cF0KaWYoSC5vVChiLiQxKG8pKSl7aWYocSl0aHJvdyBILmIoSC5BbSgpKQpyPW8KcT0hMH1pZihzIT09
-YS5sZW5ndGgpdGhyb3cgSC5iKFAuYTQoYSkpfWlmKHEpcmV0dXJuIHIKdGhyb3cgSC5iKEguV3AoKSl9
-LApFOmZ1bmN0aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1cm4gSC5PSChhLGIpCnJldHVy
-biBhW2JdfSwKZ3RIOmZ1bmN0aW9uKGEpe2lmKGEubGVuZ3RoPjApcmV0dXJuIGFbMF0KdGhyb3cgSC5i
-KEguV3AoKSl9LApnclo6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz4wKXJldHVybiBhW3Mt
-MV0KdGhyb3cgSC5iKEguV3AoKSl9LApZVzpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxwLG8K
-SC50NihhKS5DKCJjWDwxPiIpLmEoZCkKaWYoISFhLmltbXV0YWJsZSRsaXN0KUgudihQLkw0KCJzZXRS
-YW5nZSIpKQpQLmpCKGIsYyxhLmxlbmd0aCkKcz1jLWIKaWYocz09PTApcmV0dXJuClAuazEoZSwic2tp
-cENvdW50IikKaWYodC5qLmIoZCkpe3I9ZApxPWV9ZWxzZXtyPUouQTUoZCxlKS50dCgwLCExKQpxPTB9
-cD1KLlU2KHIpCmlmKHErcz5wLmdBKHIpKXRocm93IEguYihILmFyKCkpCmlmKHE8Yilmb3Iobz1zLTE7
-bz49MDstLW8pYVtiK29dPXAucShyLHErbykKZWxzZSBmb3Iobz0wO288czsrK28pYVtiK29dPXAucShy
-LHErbyl9LAp2ZzpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gdGhpcy5ZVyhhLGIsYyxkLDApfSwKVnI6
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCkgudDYoYSkuQygiYTIoMSkiKS5hKGIpCnM9YS5sZW5ndGgKZm9y
-KHI9MDtyPHM7KytyKXtpZihILm9UKGIuJDEoYVtyXSkpKXJldHVybiEwCmlmKGEubGVuZ3RoIT09cyl0
-aHJvdyBILmIoUC5hNChhKSl9cmV0dXJuITF9LAp0ZzpmdW5jdGlvbihhLGIpe3ZhciBzCmZvcihzPTA7
-czxhLmxlbmd0aDsrK3MpaWYoSi5STShhW3NdLGIpKXJldHVybiEwCnJldHVybiExfSwKZ2wwOmZ1bmN0
-aW9uKGEpe3JldHVybiBhLmxlbmd0aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3Ro
-IT09MH0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFAuV0UoYSwiWyIsIl0iKX0sCnR0OmZ1bmN0aW9uKGEs
-Yil7dmFyIHM9SC5WTShhLnNsaWNlKDApLEgudDYoYSkpCnJldHVybiBzfSwKYnI6ZnVuY3Rpb24oYSl7
-cmV0dXJuIHRoaXMudHQoYSwhMCl9LApnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEoubTEoYSxhLmxl
-bmd0aCxILnQ2KGEpLkMoIm0xPDE+IikpfSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBILmVRKGEpfSwK
-Z0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKc0E6ZnVuY3Rpb24oYSxiKXtpZighIWEuZml4
-ZWQkbGVuZ3RoKUgudihQLkw0KCJzZXQgbGVuZ3RoIikpCmlmKGI8MCl0aHJvdyBILmIoUC5URShiLDAs
-bnVsbCwibmV3TGVuZ3RoIixudWxsKSkKYS5sZW5ndGg9Yn0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIp
-CmlmKGI+PWEubGVuZ3RofHxiPDApdGhyb3cgSC5iKEguSFkoYSxiKSkKcmV0dXJuIGFbYl19LApZNTpm
-dW5jdGlvbihhLGIsYyl7SC50NihhKS5jLmEoYykKaWYoISFhLmltbXV0YWJsZSRsaXN0KUgudihQLkw0
-KCJpbmRleGVkIHNldCIpKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93IEguYihILkhZKGEsYikpCmFb
-Yl09Y30sCiRpYlE6MSwKJGljWDoxLAokaXpNOjF9CkouUG8ucHJvdG90eXBlPXt9CkoubTEucHJvdG90
-eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhp
-cyxxPXIuYSxwPXEubGVuZ3RoCmlmKHIuYiE9PXApdGhyb3cgSC5iKEgubGsocSkpCnM9ci5jCmlmKHM+
-PXApe3Iuc00obnVsbCkKcmV0dXJuITF9ci5zTShxW3NdKTsrK3IuYwpyZXR1cm4hMH0sCnNNOmZ1bmN0
-aW9uKGEpe3RoaXMuZD10aGlzLiR0aS5DKCIxPyIpLmEoYSl9LAokaUFuOjF9CkoucUkucHJvdG90eXBl
-PXsKelE6ZnVuY3Rpb24oYSl7aWYoYT4wKXtpZihhIT09MS8wKXJldHVybiBNYXRoLnJvdW5kKGEpfWVs
-c2UgaWYoYT4tMS8wKXJldHVybiAwLU1hdGgucm91bmQoMC1hKQp0aHJvdyBILmIoUC5MNCgiIithKyIu
-cm91bmQoKSIpKX0sCnc6ZnVuY3Rpb24oYSl7aWYoYT09PTAmJjEvYTwwKXJldHVybiItMC4wIgplbHNl
-IHJldHVybiIiK2F9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbz1hfDAKaWYoYT09PW8pcmV0
-dXJuIG8mNTM2ODcwOTExCnM9TWF0aC5hYnMoYSkKcj1NYXRoLmxvZyhzKS8wLjY5MzE0NzE4MDU1OTk0
-NTN8MApxPU1hdGgucG93KDIscikKcD1zPDE/cy9xOnEvcwpyZXR1cm4oKHAqOTAwNzE5OTI1NDc0MDk5
-MnwwKSsocCozNTQyMjQzMTgxMTc2NTIxfDApKSo1OTkxOTcrcioxMjU5JjUzNjg3MDkxMX0sCnpZOmZ1
-bmN0aW9uKGEsYil7dmFyIHM9YSViCmlmKHM9PT0wKXJldHVybiAwCmlmKHM+MClyZXR1cm4gcwppZihi
-PDApcmV0dXJuIHMtYgplbHNlIHJldHVybiBzK2J9LApCVTpmdW5jdGlvbihhLGIpe3JldHVybihhfDAp
-PT09YT9hL2J8MDp0aGlzLkRKKGEsYil9LApESjpmdW5jdGlvbihhLGIpe3ZhciBzPWEvYgppZihzPj0t
-MjE0NzQ4MzY0OCYmczw9MjE0NzQ4MzY0NylyZXR1cm4gc3wwCmlmKHM+MCl7aWYocyE9PTEvMClyZXR1
-cm4gTWF0aC5mbG9vcihzKX1lbHNlIGlmKHM+LTEvMClyZXR1cm4gTWF0aC5jZWlsKHMpCnRocm93IEgu
-YihQLkw0KCJSZXN1bHQgb2YgdHJ1bmNhdGluZyBkaXZpc2lvbiBpcyAiK0guRWoocykrIjogIitILkVq
-KGEpKyIgfi8gIitiKSl9LAp3RzpmdW5jdGlvbihhLGIpe3ZhciBzCmlmKGE+MClzPXRoaXMucDMoYSxi
-KQplbHNle3M9Yj4zMT8zMTpiCnM9YT4+cz4+PjB9cmV0dXJuIHN9LApiZjpmdW5jdGlvbihhLGIpe2lm
-KGI8MCl0aHJvdyBILmIoSC50TChiKSkKcmV0dXJuIHRoaXMucDMoYSxiKX0sCnAzOmZ1bmN0aW9uKGEs
-Yil7cmV0dXJuIGI+MzE/MDphPj4+Yn0sCiRpQ1A6MSwKJGlaWjoxfQpKLmJVLnByb3RvdHlwZT17JGlJ
-ZjoxfQpKLlZBLnByb3RvdHlwZT17fQpKLkRyLnByb3RvdHlwZT17Ck8yOmZ1bmN0aW9uKGEsYil7aWYo
-YjwwKXRocm93IEguYihILkhZKGEsYikpCmlmKGI+PWEubGVuZ3RoKUgudihILkhZKGEsYikpCnJldHVy
-biBhLmNoYXJDb2RlQXQoYil9LApXOmZ1bmN0aW9uKGEsYil7aWYoYj49YS5sZW5ndGgpdGhyb3cgSC5i
-KEguSFkoYSxiKSkKcmV0dXJuIGEuY2hhckNvZGVBdChiKX0sCmRkOmZ1bmN0aW9uKGEsYil7cmV0dXJu
-IG5ldyBILnVuKGIsYSwwKX0sCmg6ZnVuY3Rpb24oYSxiKXtpZih0eXBlb2YgYiE9InN0cmluZyIpdGhy
-b3cgSC5iKFAuTDMoYixudWxsLG51bGwpKQpyZXR1cm4gYStifSwKVGM6ZnVuY3Rpb24oYSxiKXt2YXIg
-cz1iLmxlbmd0aCxyPWEubGVuZ3RoCmlmKHM+cilyZXR1cm4hMQpyZXR1cm4gYj09PXRoaXMueW4oYSxy
-LXMpfSwKaTc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9UC5qQihiLGMsYS5sZW5ndGgpLHI9YS5zdWJz
-dHJpbmcoMCxiKSxxPWEuc3Vic3RyaW5nKHMpCnJldHVybiByK2QrcX0sClFpOmZ1bmN0aW9uKGEsYixj
-KXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5iKFAuVEUoYywwLGEubGVuZ3RoLG51bGws
-bnVsbCkpCnM9YytiLmxlbmd0aAppZihzPmEubGVuZ3RoKXJldHVybiExCnJldHVybiBiPT09YS5zdWJz
-dHJpbmcoYyxzKX0sCm5DOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuUWkoYSxiLDApfSwKTmo6ZnVu
-Y3Rpb24oYSxiLGMpe2lmKGM9PW51bGwpYz1hLmxlbmd0aAppZihiPDApdGhyb3cgSC5iKFAuTzcoYixu
-dWxsKSkKaWYoYj5jKXRocm93IEguYihQLk83KGIsbnVsbCkpCmlmKGM+YS5sZW5ndGgpdGhyb3cgSC5i
-KFAuTzcoYyxudWxsKSkKcmV0dXJuIGEuc3Vic3RyaW5nKGIsYyl9LAp5bjpmdW5jdGlvbihhLGIpe3Jl
-dHVybiB0aGlzLk5qKGEsYixudWxsKX0sCmhjOmZ1bmN0aW9uKGEpe3JldHVybiBhLnRvTG93ZXJDYXNl
-KCl9LApiUzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLnRyaW0oKSxvPXAubGVuZ3RoCmlmKG89PT0w
-KXJldHVybiBwCmlmKHRoaXMuVyhwLDApPT09MTMzKXtzPUoubW0ocCwxKQppZihzPT09bylyZXR1cm4i
-In1lbHNlIHM9MApyPW8tMQpxPXRoaXMuTzIocCxyKT09PTEzMz9KLmMxKHAscik6bwppZihzPT09MCYm
-cT09PW8pcmV0dXJuIHAKcmV0dXJuIHAuc3Vic3RyaW5nKHMscSl9LApUOmZ1bmN0aW9uKGEsYil7dmFy
-IHMscgppZigwPj1iKXJldHVybiIiCmlmKGI9PT0xfHxhLmxlbmd0aD09PTApcmV0dXJuIGEKaWYoYiE9
-PWI+Pj4wKXRocm93IEguYihDLkVxKQpmb3Iocz1hLHI9IiI7ITA7KXtpZigoYiYxKT09PTEpcj1zK3IK
-Yj1iPj4+MQppZihiPT09MClicmVhawpzKz1zfXJldHVybiByfSwKWFU6ZnVuY3Rpb24oYSxiLGMpe3Zh
-ciBzCmlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAsYS5sZW5ndGgsbnVsbCxudWxs
-KSkKcz1hLmluZGV4T2YoYixjKQpyZXR1cm4gc30sCk9ZOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMu
-WFUoYSxiLDApfSwKUGs6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKaWYoYz09bnVsbCljPWEubGVuZ3Ro
-CmVsc2UgaWYoYzwwfHxjPmEubGVuZ3RoKXRocm93IEguYihQLlRFKGMsMCxhLmxlbmd0aCxudWxsLG51
-bGwpKQpzPWIubGVuZ3RoCnI9YS5sZW5ndGgKaWYoYytzPnIpYz1yLXMKcmV0dXJuIGEubGFzdEluZGV4
-T2YoYixjKX0sCmNuOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuUGsoYSxiLG51bGwpfSwKSXM6ZnVu
-Y3Rpb24oYSxiLGMpe3ZhciBzPWEubGVuZ3RoCmlmKGM+cyl0aHJvdyBILmIoUC5URShjLDAscyxudWxs
-LG51bGwpKQpyZXR1cm4gSC5TUShhLGIsYyl9LAp0ZzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLklz
-KGEsYiwwKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIGF9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixx
-CmZvcihzPWEubGVuZ3RoLHI9MCxxPTA7cTxzOysrcSl7cj1yK2EuY2hhckNvZGVBdChxKSY1MzY4NzA5
-MTEKcj1yKygociY1MjQyODcpPDwxMCkmNTM2ODcwOTExCnJePXI+PjZ9cj1yKygociY2NzEwODg2Myk8
-PDMpJjUzNjg3MDkxMQpyXj1yPj4xMQpyZXR1cm4gcisoKHImMTYzODMpPDwxNSkmNTM2ODcwOTExfSwK
-Z0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYo
-Yj49YS5sZW5ndGh8fCExKXRocm93IEguYihILkhZKGEsYikpCnJldHVybiBhW2JdfSwKJGl2WDoxLAok
-aXFVOjF9CkguQlIucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9SC5MaCh0aGlzKQpyZXR1
-cm4gbmV3IEguRTcoSi5JVCh0aGlzLmdPTigpKSxzLkMoIkA8MT4iKS5LcShzLlFbMV0pLkMoIkU3PDEs
-Mj4iKSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gSi5IbSh0aGlzLmdPTigpKX0sCmdsMDpmdW5jdGlv
-bihhKXtyZXR1cm4gSi51VSh0aGlzLmdPTigpKX0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gSi5GNyh0
-aGlzLmdPTigpKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5MaCh0aGlzKQpyZXR1cm4gSC5HSihK
-LkE1KHRoaXMuZ09OKCksYikscy5jLHMuUVsxXSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEguTGgo
-dGhpcykuUVsxXS5hKEouR0EodGhpcy5nT04oKSxiKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBKLmoo
-dGhpcy5nT04oKSl9fQpILkU3LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLkYo
-KX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuJHRpLlFbMV0uYSh0aGlzLmEuZ2woKSl9LAokaUFu
-OjF9CkguWnkucHJvdG90eXBlPXsKZ09OOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX19Ckgub2wucHJv
-dG90eXBlPXskaWJROjF9CkguVXEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlz
-LiR0aS5RWzFdLmEoSi54OSh0aGlzLmEsSC51UChiKSkpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBz
-PXRoaXMuJHRpCkoudTkodGhpcy5hLGIscy5jLmEocy5RWzFdLmEoYykpKX0sCiRpYlE6MSwKJGl6TTox
-fQpILmpWLnByb3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILmpWKHRoaXMuYSx0
-aGlzLiR0aS5DKCJAPDE+IikuS3EoYikuQygialY8MSwyPiIpKX0sCmdPTjpmdW5jdGlvbigpe3JldHVy
-biB0aGlzLmF9fQpILm4ucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJu
-IHMhPW51bGw/IkxhdGVJbml0aWFsaXphdGlvbkVycm9yOiAiK3M6IkxhdGVJbml0aWFsaXphdGlvbkVy
-cm9yIn19CkgucjMucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz0iUmVhY2hhYmlsaXR5RXJy
-b3I6ICIrdGhpcy5hCnJldHVybiBzfX0KSC5xai5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1
-cm4gdGhpcy5hLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gQy54Qi5PMih0aGlzLmEsSC51
-UChiKSl9fQpILkdNLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk51bGwgaXMgbm90IGEg
-dmFsaWQgdmFsdWUgZm9yIHRoZSBwYXJhbWV0ZXIgJyIrdGhpcy5hKyInIG9mIHR5cGUgJyIrSC5LeCh0
-aGlzLiR0aS5jKS53KDApKyInIn19CkguYlEucHJvdG90eXBlPXt9CkguYUwucHJvdG90eXBlPXsKZ206
-ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpyZXR1cm4gbmV3IEguYTcocyxzLmdBKHMpLEguTGgocykuQygi
-YTc8YUwuRT4iKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcyk9PT0wfSwKazpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPXRoaXMsbz1wLmdBKHApCmlmKGIubGVuZ3RoIT09MCl7aWYo
-bz09PTApcmV0dXJuIiIKcz1ILkVqKHAuRSgwLDApKQppZihvIT09cC5nQShwKSl0aHJvdyBILmIoUC5h
-NChwKSkKZm9yKHI9cyxxPTE7cTxvOysrcSl7cj1yK2IrSC5FaihwLkUoMCxxKSkKaWYobyE9PXAuZ0Eo
-cCkpdGhyb3cgSC5iKFAuYTQocCkpfXJldHVybiByLmNoYXJDb2RlQXQoMCk9PTA/cjpyfWVsc2V7Zm9y
-KHE9MCxyPSIiO3E8bzsrK3Epe3IrPUguRWoocC5FKDAscSkpCmlmKG8hPT1wLmdBKHApKXRocm93IEgu
-YihQLmE0KHApKX1yZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn19LApldjpmdW5jdGlvbihhLGIp
-e3JldHVybiB0aGlzLkdHKDAsSC5MaCh0aGlzKS5DKCJhMihhTC5FKSIpLmEoYikpfSwKRTI6ZnVuY3Rp
-b24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILmxKKHRoaXMscy5LcShjKS5DKCIx
-KGFMLkUpIikuYShiKSxzLkMoIkA8YUwuRT4iKS5LcShjKS5DKCJsSjwxLDI+IikpfSwKZVI6ZnVuY3Rp
-b24oYSxiKXtyZXR1cm4gSC5xQyh0aGlzLGIsbnVsbCxILkxoKHRoaXMpLkMoImFMLkUiKSl9LAp0dDpm
-dW5jdGlvbihhLGIpe3JldHVybiBQLlkxKHRoaXMsITAsSC5MaCh0aGlzKS5DKCJhTC5FIikpfSwKYnI6
-ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9fQpILm5ILnByb3RvdHlwZT17CkhkOmZ1bmN0
-aW9uKGEsYixjLGQpe3ZhciBzLHI9dGhpcy5iClAuazEociwic3RhcnQiKQpzPXRoaXMuYwppZihzIT1u
-dWxsKXtQLmsxKHMsImVuZCIpCmlmKHI+cyl0aHJvdyBILmIoUC5URShyLDAscywic3RhcnQiLG51bGwp
-KX19LApnVUQ6ZnVuY3Rpb24oKXt2YXIgcz1KLkhtKHRoaXMuYSkscj10aGlzLmMKaWYocj09bnVsbHx8
-cj5zKXJldHVybiBzCnJldHVybiByfSwKZ0FzOmZ1bmN0aW9uKCl7dmFyIHM9Si5IbSh0aGlzLmEpLHI9
-dGhpcy5iCmlmKHI+cylyZXR1cm4gcwpyZXR1cm4gcn0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9Si5I
-bSh0aGlzLmEpLHE9dGhpcy5iCmlmKHE+PXIpcmV0dXJuIDAKcz10aGlzLmMKaWYocz09bnVsbHx8cz49
-cilyZXR1cm4gci1xCmlmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIHMuSE4oKQpyZXR1cm4gcy1x
-fSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMscj1zLmdBcygpK2IKaWYoYjwwfHxyPj1zLmdVRCgp
-KXRocm93IEguYihQLkNmKGIscywiaW5kZXgiLG51bGwsbnVsbCkpCnJldHVybiBKLkdBKHMuYSxyKX0s
-CmVSOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKUC5rMShiLCJjb3VudCIpCnM9cS5iK2IKcj1x
-LmMKaWYociE9bnVsbCYmcz49cilyZXR1cm4gbmV3IEguTUIocS4kdGkuQygiTUI8MT4iKSkKcmV0dXJu
-IEgucUMocS5hLHMscixxLiR0aS5jKX0sCnR0OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHA9dGhpcyxv
-PXAuYixuPXAuYSxtPUouVTYobiksbD1tLmdBKG4pLGs9cC5jCmlmKGshPW51bGwmJms8bClsPWsKaWYo
-dHlwZW9mIGwhPT0ibnVtYmVyIilyZXR1cm4gbC5ITigpCnM9bC1vCmlmKHM8PTApe249Si5RaSgwLHAu
-JHRpLmMpCnJldHVybiBufXI9UC5POChzLG0uRShuLG8pLCExLHAuJHRpLmMpCmZvcihxPTE7cTxzOysr
-cSl7Qy5ObS5ZNShyLHEsbS5FKG4sbytxKSkKaWYobS5nQShuKTxsKXRocm93IEguYihQLmE0KHApKX1y
-ZXR1cm4gcn19CkguYTcucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpm
-dW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxwPUouVTYocSksbz1wLmdBKHEpCmlmKHIuYiE9PW8p
-dGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM+PW8pe3Iuc0kobnVsbCkKcmV0dXJuITF9ci5zSShw
-LkUocSxzKSk7KytyLmMKcmV0dXJuITB9LApzSTpmdW5jdGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygi
-MT8iKS5hKGEpfSwKJGlBbjoxfQpILmkxLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPUgu
-TGgodGhpcykKcmV0dXJuIG5ldyBILk1IKEouSVQodGhpcy5hKSx0aGlzLmIscy5DKCJAPDE+IikuS3Eo
-cy5RWzFdKS5DKCJNSDwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhpcy5hKX0s
-CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmEpfSwKRTpmdW5jdGlvbihhLGIpe3JldHVy
-biB0aGlzLmIuJDEoSi5HQSh0aGlzLmEsYikpfX0KSC54eS5wcm90b3R5cGU9eyRpYlE6MX0KSC5NSC5w
-cm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYgppZihyLkYoKSl7cy5zSShzLmMu
-JDEoci5nbCgpKSkKcmV0dXJuITB9cy5zSShudWxsKQpyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0
-dXJuIHRoaXMuYX0sCnNJOmZ1bmN0aW9uKGEpe3RoaXMuYT10aGlzLiR0aS5DKCIyPyIpLmEoYSl9fQpI
-LmxKLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBKLkhtKHRoaXMuYSl9LApFOmZ1bmN0
-aW9uKGEsYil7cmV0dXJuIHRoaXMuYi4kMShKLkdBKHRoaXMuYSxiKSl9fQpILlU1LnByb3RvdHlwZT17
-CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5TTyhKLklUKHRoaXMuYSksdGhpcy5iLHRoaXMuJHRp
-LkMoIlNPPDE+IikpfX0KSC5TTy5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10
-aGlzLmEscj10aGlzLmI7cy5GKCk7KWlmKEgub1Qoci4kMShzLmdsKCkpKSlyZXR1cm4hMApyZXR1cm4h
-MX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5nbCgpfX0KSC5BTS5wcm90b3R5cGU9ewplUjpm
-dW5jdGlvbihhLGIpe1AuTVIoYiwiY291bnQiLHQuUykKUC5rMShiLCJjb3VudCIpCnJldHVybiBuZXcg
-SC5BTSh0aGlzLmEsdGhpcy5iK2IsSC5MaCh0aGlzKS5DKCJBTTwxPiIpKX0sCmdtOmZ1bmN0aW9uKGEp
-e3JldHVybiBuZXcgSC5VMShKLklUKHRoaXMuYSksdGhpcy5iLEguTGgodGhpcykuQygiVTE8MT4iKSl9
-fQpILmQ1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3ZhciBzPUouSG0odGhpcy5hKS10aGlzLmIK
-aWYocz49MClyZXR1cm4gcwpyZXR1cm4gMH0sCmVSOmZ1bmN0aW9uKGEsYil7UC5NUihiLCJjb3VudCIs
-dC5TKQpQLmsxKGIsImNvdW50IikKcmV0dXJuIG5ldyBILmQ1KHRoaXMuYSx0aGlzLmIrYix0aGlzLiR0
-aSl9LAokaWJROjF9CkguVTEucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzLHIKZm9yKHM9dGhp
-cy5hLHI9MDtyPHRoaXMuYjsrK3Ipcy5GKCkKdGhpcy5iPTAKcmV0dXJuIHMuRigpfSwKZ2w6ZnVuY3Rp
-b24oKXtyZXR1cm4gdGhpcy5hLmdsKCl9fQpILk1CLnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3Jl
-dHVybiBDLkd3fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiEwfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJu
-IDB9LApFOmZ1bmN0aW9uKGEsYil7dGhyb3cgSC5iKFAuVEUoYiwwLDAsImluZGV4IixudWxsKSl9LApl
-UjpmdW5jdGlvbihhLGIpe1AuazEoYiwiY291bnQiKQpyZXR1cm4gdGhpc319CkguRnUucHJvdG90eXBl
-PXsKRjpmdW5jdGlvbigpe3JldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXt0aHJvdyBILmIoSC5XcCgpKX0s
-CiRpQW46MX0KSC51Ni5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguSkIoSi5J
-VCh0aGlzLmEpLHRoaXMuJHRpLkMoIkpCPDE+IikpfX0KSC5KQi5wcm90b3R5cGU9ewpGOmZ1bmN0aW9u
-KCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLiR0aS5jO3MuRigpOylpZihyLmIocy5nbCgpKSly
-ZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuJHRpLmMuYSh0aGlzLmEu
-Z2woKSl9LAokaUFuOjF9CkguU1UucHJvdG90eXBlPXt9CkguUmUucHJvdG90eXBlPXsKWTU6ZnVuY3Rp
-b24oYSxiLGMpe0guTGgodGhpcykuQygiUmUuRSIpLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBt
-b2RpZnkgYW4gdW5tb2RpZmlhYmxlIGxpc3QiKSl9fQpILncyLnByb3RvdHlwZT17fQpILnd2LnByb3Rv
-dHlwZT17CmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLl9oYXNoQ29kZQppZihzIT1udWxsKXJldHVy
-biBzCnM9NjY0NTk3KkouaGYodGhpcy5hKSY1MzY4NzA5MTEKdGhpcy5faGFzaENvZGU9cwpyZXR1cm4g
-c30sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuJ1N5bWJvbCgiJytILkVqKHRoaXMuYSkrJyIpJ30sCkROOmZ1
-bmN0aW9uKGEsYil7aWYoYj09bnVsbClyZXR1cm4hMQpyZXR1cm4gYiBpbnN0YW5jZW9mIEgud3YmJnRo
-aXMuYT09Yi5hfSwKJGlHRDoxfQpILlFDLnByb3RvdHlwZT17fQpILlBELnByb3RvdHlwZT17fQpILldV
-LnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKT09PTB9LAp3OmZ1
-bmN0aW9uKGEpe3JldHVybiBQLm5PKHRoaXMpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgo
-dGhpcykKcy5jLmEoYikKcy5RWzFdLmEoYykKSC5kYygpCkguQmkodS5nKX0sCmdQdTpmdW5jdGlvbihh
-KXtyZXR1cm4gdGhpcy5xNChhLEguTGgodGhpcykuQygiTjM8MSwyPiIpKX0sCnE0OmZ1bmN0aW9uKGEs
-Yil7dmFyIHM9dGhpcwpyZXR1cm4gUC5sMChmdW5jdGlvbigpe3ZhciByPWEKdmFyIHE9MCxwPTEsbyxu
-LG0sbCxrCnJldHVybiBmdW5jdGlvbiAkYXN5bmMkZ1B1KGMsZCl7aWYoYz09PTEpe289ZApxPXB9d2hp
-bGUodHJ1ZSlzd2l0Y2gocSl7Y2FzZSAwOm49cy5ndmMoKSxuPW4uZ20obiksbT1ILkxoKHMpLG09bS5D
-KCJAPDE+IikuS3EobS5RWzFdKS5DKCJOMzwxLDI+IikKY2FzZSAyOmlmKCFuLkYoKSl7cT0zCmJyZWFr
-fWw9bi5nbCgpCms9cy5xKDAsbCkKay50b1N0cmluZwpxPTQKcmV0dXJuIG5ldyBQLk4zKGwsayxtKQpj
-YXNlIDQ6cT0yCmJyZWFrCmNhc2UgMzpyZXR1cm4gUC5UaCgpCmNhc2UgMTpyZXR1cm4gUC5ZbShvKX19
-fSxiKX0sCiRpWjA6MX0KSC5MUC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5h
-fSwKeDQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGEhPSJzdHJpbmciKXJldHVybiExCmlmKCJfX3Byb3Rv
-X18iPT09YSlyZXR1cm4hMQpyZXR1cm4gdGhpcy5iLmhhc093blByb3BlcnR5KGEpfSwKcTpmdW5jdGlv
-bihhLGIpe2lmKCF0aGlzLng0KGIpKXJldHVybiBudWxsCnJldHVybiB0aGlzLnFQKGIpfSwKcVA6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIHRoaXMuYltILmgoYSldfSwKSzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxw
-LG89SC5MaCh0aGlzKQpvLkMoIn4oMSwyKSIpLmEoYikKcz10aGlzLmMKZm9yKHI9cy5sZW5ndGgsbz1v
-LlFbMV0scT0wO3E8cjsrK3Epe3A9c1txXQpiLiQyKHAsby5hKHRoaXMucVAocCkpKX19LApndmM6ZnVu
-Y3Rpb24oKXtyZXR1cm4gbmV3IEguWFIodGhpcyxILkxoKHRoaXMpLkMoIlhSPDE+IikpfX0KSC5YUi5w
-cm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEuYwpyZXR1cm4gbmV3IEoubTEocyxz
-Lmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5j
-Lmxlbmd0aH19CkguTEkucHJvdG90eXBlPXsKZ1dhOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5hCnJldHVy
-biBzfSwKZ25kOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlmKG8uYz09PTEpcmV0dXJuIEMu
-aFUKcz1vLmQKcj1zLmxlbmd0aC1vLmUubGVuZ3RoLW8uZgppZihyPT09MClyZXR1cm4gQy5oVQpxPVtd
-CmZvcihwPTA7cDxyOysrcCl7aWYocD49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxwKQpxLnB1c2goc1tw
-XSl9cmV0dXJuIEouekMocSl9LApnVm06ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhp
-cwppZihrLmMhPT0wKXJldHVybiBDLldPCnM9ay5lCnI9cy5sZW5ndGgKcT1rLmQKcD1xLmxlbmd0aC1y
-LWsuZgppZihyPT09MClyZXR1cm4gQy5XTwpvPW5ldyBILk41KHQuZW8pCmZvcihuPTA7bjxyOysrbil7
-aWYobj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxuKQptPXNbbl0KbD1wK24KaWYobDwwfHxsPj1xLmxl
-bmd0aClyZXR1cm4gSC5PSChxLGwpCm8uWTUoMCxuZXcgSC53dihtKSxxW2xdKX1yZXR1cm4gbmV3IEgu
-UEQobyx0LmdGKX0sCiRpdlE6MX0KSC5Dai5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBz
-CkguaChhKQpzPXRoaXMuYQpzLmI9cy5iKyIkIitILkVqKGEpCkMuTm0uaSh0aGlzLmIsYSkKQy5ObS5p
-KHRoaXMuYyxiKTsrK3MuYX0sCiRTOjEyfQpILmY5LnByb3RvdHlwZT17CnFTOmZ1bmN0aW9uKGEpe3Zh
-ciBzLHIscT10aGlzLHA9bmV3IFJlZ0V4cChxLmEpLmV4ZWMoYSkKaWYocD09bnVsbClyZXR1cm4gbnVs
-bApzPU9iamVjdC5jcmVhdGUobnVsbCkKcj1xLmIKaWYociE9PS0xKXMuYXJndW1lbnRzPXBbcisxXQpy
-PXEuYwppZihyIT09LTEpcy5hcmd1bWVudHNFeHByPXBbcisxXQpyPXEuZAppZihyIT09LTEpcy5leHBy
-PXBbcisxXQpyPXEuZQppZihyIT09LTEpcy5tZXRob2Q9cFtyKzFdCnI9cS5mCmlmKHIhPT0tMSlzLnJl
-Y2VpdmVyPXBbcisxXQpyZXR1cm4gc319CkguVzAucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIg
-cz10aGlzLmIKaWYocz09bnVsbClyZXR1cm4iTm9TdWNoTWV0aG9kRXJyb3I6ICIrSC5Faih0aGlzLmEp
-CnJldHVybiJOb1N1Y2hNZXRob2RFcnJvcjogbWV0aG9kIG5vdCBmb3VuZDogJyIrcysiJyBvbiBudWxs
-In19CkguYXoucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMscT0iTm9TdWNoTWV0
-aG9kRXJyb3I6IG1ldGhvZCBub3QgZm91bmQ6ICciLHA9ci5iCmlmKHA9PW51bGwpcmV0dXJuIk5vU3Vj
-aE1ldGhvZEVycm9yOiAiK0guRWooci5hKQpzPXIuYwppZihzPT1udWxsKXJldHVybiBxK3ArIicgKCIr
-SC5FaihyLmEpKyIpIgpyZXR1cm4gcStwKyInIG9uICciK3MrIicgKCIrSC5FaihyLmEpKyIpIn19Ckgu
-dlYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMubGVuZ3RoPT09
-MD8iRXJyb3IiOiJFcnJvcjogIitzfX0KSC50ZS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVy
-biJUaHJvdyBvZiBudWxsICgnIisodGhpcy5hPT09bnVsbD8ibnVsbCI6InVuZGVmaW5lZCIpKyInIGZy
-b20gSmF2YVNjcmlwdCkifSwKJGlSejoxfQpILmJxLnByb3RvdHlwZT17fQpILlhPLnByb3RvdHlwZT17
-Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLmIKaWYociE9bnVsbClyZXR1cm4gcgpyPXRoaXMuYQpz
-PXIhPT1udWxsJiZ0eXBlb2Ygcj09PSJvYmplY3QiP3Iuc3RhY2s6bnVsbApyZXR1cm4gdGhpcy5iPXM9
-PW51bGw/IiI6c30sCiRpR3o6MX0KSC5UcC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPXRo
-aXMuY29uc3RydWN0b3Iscj1zPT1udWxsP251bGw6cy5uYW1lCnJldHVybiJDbG9zdXJlICciK0guTlEo
-cj09bnVsbD8idW5rbm93biI6cikrIicifSwKJGlFSDoxLApnS3U6ZnVuY3Rpb24oKXtyZXR1cm4gdGhp
-c30sCiRDOiIkMSIsCiRSOjEsCiREOm51bGx9CkgubGMucHJvdG90eXBlPXt9CkguengucHJvdG90eXBl
-PXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiRzdGF0aWNfbmFtZQppZihzPT1udWxsKXJldHVybiJD
-bG9zdXJlIG9mIHVua25vd24gc3RhdGljIG1ldGhvZCIKcmV0dXJuIkNsb3N1cmUgJyIrSC5OUShzKSsi
-JyJ9fQpILnJULnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcwppZihiPT1udWxs
-KXJldHVybiExCmlmKHM9PT1iKXJldHVybiEwCmlmKCEoYiBpbnN0YW5jZW9mIEguclQpKXJldHVybiEx
-CnJldHVybiBzLmE9PT1iLmEmJnMuYj09PWIuYiYmcy5jPT09Yi5jfSwKZ2lPOmZ1bmN0aW9uKGEpe3Zh
-ciBzLHI9dGhpcy5jCmlmKHI9PW51bGwpcz1ILmVRKHRoaXMuYSkKZWxzZSBzPXR5cGVvZiByIT09Im9i
-amVjdCI/Si5oZihyKTpILmVRKHIpCnI9SC5lUSh0aGlzLmIpCmlmKHR5cGVvZiBzIT09Im51bWJlciIp
-cmV0dXJuIHMuWSgpCnJldHVybihzXnIpPj4+MH0sCnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCmlm
-KHM9PW51bGwpcz10aGlzLmEKcmV0dXJuIkNsb3N1cmUgJyIrSC5Faih0aGlzLmQpKyInIG9mICIrKCJJ
-bnN0YW5jZSBvZiAnIitILkVqKEguTShzKSkrIiciKX19CkguRXEucHJvdG90eXBlPXsKdzpmdW5jdGlv
-bihhKXtyZXR1cm4iUnVudGltZUVycm9yOiAiK3RoaXMuYX19Ckgua1kucHJvdG90eXBlPXsKdzpmdW5j
-dGlvbihhKXtyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDogIitQLnAodGhpcy5hKX19Ckgua3IucHJvdG90
-eXBlPXt9CkguTjUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpm
-dW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09MH0sCmd2YzpmdW5jdGlvbigpe3JldHVybiBuZXcgSC5p
-NSh0aGlzLEguTGgodGhpcykuQygiaTU8MT4iKSl9LAp4NDpmdW5jdGlvbihhKXt2YXIgcyxyCmlmKHR5
-cGVvZiBhPT0ic3RyaW5nIil7cz10aGlzLmIKaWYocz09bnVsbClyZXR1cm4hMQpyZXR1cm4gdGhpcy5Y
-dShzLGEpfWVsc2V7cj10aGlzLkNYKGEpCnJldHVybiByfX0sCkNYOmZ1bmN0aW9uKGEpe3ZhciBzPXRo
-aXMuZAppZihzPT1udWxsKXJldHVybiExCnJldHVybiB0aGlzLkZoKHRoaXMuQnQocyxKLmhmKGEpJjB4
-M2ZmZmZmZiksYSk+PTB9LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbz10aGlzLG49bnVsbApp
-Zih0eXBlb2YgYj09InN0cmluZyIpe3M9by5iCmlmKHM9PW51bGwpcmV0dXJuIG4Kcj1vLmoyKHMsYikK
-cT1yPT1udWxsP246ci5iCnJldHVybiBxfWVsc2UgaWYodHlwZW9mIGI9PSJudW1iZXIiJiYoYiYweDNm
-ZmZmZmYpPT09Yil7cD1vLmMKaWYocD09bnVsbClyZXR1cm4gbgpyPW8uajIocCxiKQpxPXI9PW51bGw/
-bjpyLmIKcmV0dXJuIHF9ZWxzZSByZXR1cm4gby5hYShiKX0sCmFhOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cT10aGlzLmQKaWYocT09bnVsbClyZXR1cm4gbnVsbApzPXRoaXMuQnQocSxKLmhmKGEpJjB4M2ZmZmZm
-ZikKcj10aGlzLkZoKHMsYSkKaWYocjwwKXJldHVybiBudWxsCnJldHVybiBzW3JdLmJ9LApZNTpmdW5j
-dGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPUguTGgobSkKbC5jLmEoYikKbC5RWzFd
-LmEoYykKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPW0uYgptLkVIKHM9PW51bGw/bS5iPW0ueksoKTpz
-LGIsYyl9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJlciImJihiJjB4M2ZmZmZmZik9PT1iKXtyPW0uYwpt
-LkVIKHI9PW51bGw/bS5jPW0ueksoKTpyLGIsYyl9ZWxzZXtxPW0uZAppZihxPT1udWxsKXE9bS5kPW0u
-eksoKQpwPUouaGYoYikmMHgzZmZmZmZmCm89bS5CdChxLHApCmlmKG89PW51bGwpbS5FSShxLHAsW20u
-SG4oYixjKV0pCmVsc2V7bj1tLkZoKG8sYikKaWYobj49MClvW25dLmI9YwplbHNlIG8ucHVzaChtLkhu
-KGIsYykpfX19LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKSC5MaChxKS5DKCJ+KDEsMiki
-KS5hKGIpCnM9cS5lCnI9cS5yCmZvcig7cyE9bnVsbDspe2IuJDIocy5hLHMuYikKaWYociE9PXEucil0
-aHJvdyBILmIoUC5hNChxKSkKcz1zLmN9fSwKRUg6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9dGhpcyxx
-PUguTGgocikKcS5jLmEoYikKcS5RWzFdLmEoYykKcz1yLmoyKGEsYikKaWYocz09bnVsbClyLkVJKGEs
-YixyLkhuKGIsYykpCmVsc2Ugcy5iPWN9LAprczpmdW5jdGlvbigpe3RoaXMucj10aGlzLnIrMSY2NzEw
-ODg2M30sCkhuOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcyxyPUguTGgocykscT1uZXcgSC52aChyLmMu
-YShhKSxyLlFbMV0uYShiKSkKaWYocy5lPT1udWxsKXMuZT1zLmY9cQplbHNle3I9cy5mCnIudG9TdHJp
-bmcKcS5kPXIKcy5mPXIuYz1xfSsrcy5hCnMua3MoKQpyZXR1cm4gcX0sCkZoOmZ1bmN0aW9uKGEsYil7
-dmFyIHMscgppZihhPT1udWxsKXJldHVybi0xCnM9YS5sZW5ndGgKZm9yKHI9MDtyPHM7KytyKWlmKEou
-Uk0oYVtyXS5hLGIpKXJldHVybiByCnJldHVybi0xfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gUC5uTyh0
-aGlzKX0sCmoyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGFbYl19LApCdDpmdW5jdGlvbihhLGIpe3JldHVy
-biBhW2JdfSwKRUk6ZnVuY3Rpb24oYSxiLGMpe2FbYl09Y30sCnJuOmZ1bmN0aW9uKGEsYil7ZGVsZXRl
-IGFbYl19LApYdTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmoyKGEsYikhPW51bGx9LAp6SzpmdW5j
-dGlvbigpe3ZhciBzPSI8bm9uLWlkZW50aWZpZXIta2V5PiIscj1PYmplY3QuY3JlYXRlKG51bGwpCnRo
-aXMuRUkocixzLHIpCnRoaXMucm4ocixzKQpyZXR1cm4gcn0sCiRpRm86MX0KSC52aC5wcm90b3R5cGU9
-e30KSC5pNS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmF9LApnbDA6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5hPT09MH0sCmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYSxy
-PW5ldyBILk42KHMscy5yLHRoaXMuJHRpLkMoIk42PDE+IikpCnIuYz1zLmUKcmV0dXJuIHJ9LAp0Zzpm
-dW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEueDQoYil9fQpILk42LnByb3RvdHlwZT17CmdsOmZ1bmN0
-aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxyPXRoaXMscT1yLmEKaWYoci5i
-IT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXIuYwppZihzPT1udWxsKXtyLnNxWShudWxsKQpyZXR1
-cm4hMX1lbHNle3Iuc3FZKHMuYSkKci5jPXMuYwpyZXR1cm4hMH19LApzcVk6ZnVuY3Rpb24oYSl7dGhp
-cy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KSC5kQy5wcm90b3R5cGU9ewokMTpmdW5j
-dGlvbihhKXtyZXR1cm4gdGhpcy5hKGEpfSwKJFM6NH0KSC53Ti5wcm90b3R5cGU9ewokMjpmdW5jdGlv
-bihhLGIpe3JldHVybiB0aGlzLmEoYSxiKX0sCiRTOjQ2fQpILlZYLnByb3RvdHlwZT17CiQxOmZ1bmN0
-aW9uKGEpe3JldHVybiB0aGlzLmEoSC5oKGEpKX0sCiRTOjQxfQpILlZSLnByb3RvdHlwZT17Cnc6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIlJlZ0V4cC8iK3RoaXMuYSsiLyIrdGhpcy5iLmZsYWdzfSwKZ0hjOmZ1bmN0
-aW9uKCl7dmFyIHM9dGhpcyxyPXMuYwppZihyIT1udWxsKXJldHVybiByCnI9cy5iCnJldHVybiBzLmM9
-SC52NChzLmEsci5tdWx0aWxpbmUsIXIuaWdub3JlQ2FzZSxyLnVuaWNvZGUsci5kb3RBbGwsITApfSwK
-ZGQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguS1codGhpcyxiLDApfSwKVVo6ZnVuY3Rpb24oYSxi
-KXt2YXIgcyxyPXRoaXMuZ0hjKCkKci5sYXN0SW5kZXg9YgpzPXIuZXhlYyhhKQppZihzPT1udWxsKXJl
-dHVybiBudWxsCnJldHVybiBuZXcgSC5FSyhzKX0sCiRpdlg6MSwKJGl3TDoxfQpILkVLLnByb3RvdHlw
-ZT17CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIpCnM9dGhpcy5iCmlmKGI+PXMubGVuZ3RoKXJl
-dHVybiBILk9IKHMsYikKcmV0dXJuIHNbYl19LAokaU9kOjEsCiRpaWI6MX0KSC5LVy5wcm90b3R5cGU9
-ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguUGIodGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5Q
-Yi5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9LApGOmZ1bmN0aW9uKCl7dmFy
-IHMscixxLHAsbyxuLG09dGhpcyxsPW0uYgppZihsPT1udWxsKXJldHVybiExCnM9bS5jCnI9bC5sZW5n
-dGgKaWYoczw9cil7cT1tLmEKcD1xLlVaKGwscykKaWYocCE9bnVsbCl7bS5kPXAKcz1wLmIKbz1zLmlu
-ZGV4Cm49bytzWzBdLmxlbmd0aAppZihvPT09bil7aWYocS5iLnVuaWNvZGUpe3M9bS5jCnE9cysxCmlm
-KHE8cil7cz1DLnhCLk8yKGwscykKaWYocz49NTUyOTYmJnM8PTU2MzE5KXtzPUMueEIuTzIobCxxKQpz
-PXM+PTU2MzIwJiZzPD01NzM0M31lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMQpuPShzP24rMTpu
-KSsxfW0uYz1uCnJldHVybiEwfX1tLmI9bS5kPW51bGwKcmV0dXJuITF9LAokaUFuOjF9CkgudFEucHJv
-dG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYiE9PTApSC52KFAuTzcoYixudWxsKSkK
-cmV0dXJuIHRoaXMuY30sCiRpT2Q6MX0KSC51bi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1
-cm4gbmV3IEguU2QodGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5TZC5wcm90b3R5cGU9ewpGOmZ1bmN0
-aW9uKCl7dmFyIHMscixxPXRoaXMscD1xLmMsbz1xLmIsbj1vLmxlbmd0aCxtPXEuYSxsPW0ubGVuZ3Ro
-CmlmKHArbj5sKXtxLmQ9bnVsbApyZXR1cm4hMX1zPW0uaW5kZXhPZihvLHApCmlmKHM8MCl7cS5jPWwr
-MQpxLmQ9bnVsbApyZXR1cm4hMX1yPXMrbgpxLmQ9bmV3IEgudFEocyxvKQpxLmM9cj09PXEuYz9yKzE6
-cgpyZXR1cm4hMH0sCmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5kCnMudG9TdHJpbmcKcmV0dXJuIHN9
-LAokaUFuOjF9CkguRVQucHJvdG90eXBlPXskaUVUOjEsJGlBUzoxfQpILkxaLnByb3RvdHlwZT17CmdB
-OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCiRpWGo6MX0KSC5EZy5wcm90b3R5cGU9ewpxOmZ1
-bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LApZNTpmdW5j
-dGlvbihhLGIsYyl7SC5HSChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUToxLAokaWNY
-OjEsCiRpek06MX0KSC5QZy5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihhLGIsYyl7SC51UChjKQpILm9k
-KGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0KSC54ai5wcm90b3R5
+bihhLGIpe3JldHVybiBuZXcgUC5xNChhLGIuQygicTQ8MD4iKSl9LApBOTpmdW5jdGlvbihhLGIpe3Zh
+ciBzLHIscQpmb3Iocz10LmM7cj1hLmEscj09PTI7KWE9cy5hKGEuYykKaWYocj49NCl7cT1iLmFoKCkK
+Yi5hPWEuYQpiLmM9YS5jClAuSFooYixxKX1lbHNle3E9dC5GLmEoYi5jKQpiLmE9MgpiLmM9YQphLmpR
+KHEpfX0sCkhaOmZ1bmN0aW9uKGEwLGExKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUs
+ZCxjPW51bGwsYj17fSxhPWIuYT1hMApmb3Iocz10Lm4scj10LkYscT10LmU7ITA7KXtwPXt9Cm89YS5h
+PT09OAppZihhMT09bnVsbCl7aWYobyl7bj1zLmEoYS5jKQpQLkwyKGMsYyxhLmIsbi5hLG4uYil9cmV0
+dXJufXAuYT1hMQptPWExLmEKZm9yKGE9YTE7bSE9bnVsbDthPW0sbT1sKXthLmE9bnVsbApQLkhaKGIu
+YSxhKQpwLmE9bQpsPW0uYX1rPWIuYQpqPWsuYwpwLmI9bwpwLmM9agppPSFvCmlmKGkpe2g9YS5jCmg9
+KGgmMSkhPT0wfHwoaCYxNSk9PT04fWVsc2UgaD0hMAppZihoKXtnPWEuYi5iCmlmKG8pe2g9ay5iPT09
+ZwpoPSEoaHx8aCl9ZWxzZSBoPSExCmlmKGgpe3MuYShqKQpQLkwyKGMsYyxrLmIsai5hLGouYikKcmV0
+dXJufWY9JC5YMwppZihmIT09ZykkLlgzPWcKZWxzZSBmPWMKYT1hLmMKaWYoKGEmMTUpPT09OCluZXcg
+UC5SVChwLGIsbykuJDAoKQplbHNlIGlmKGkpe2lmKChhJjEpIT09MCluZXcgUC5ycShwLGopLiQwKCl9
+ZWxzZSBpZigoYSYyKSE9PTApbmV3IFAuUlcoYixwKS4kMCgpCmlmKGYhPW51bGwpJC5YMz1mCmE9cC5j
+CmlmKHEuYihhKSl7az1wLmEuJHRpCms9ay5DKCJiODwyPiIpLmIoYSl8fCFrLlFbMV0uYihhKX1lbHNl
+IGs9ITEKaWYoayl7cS5hKGEpCmU9cC5hLmIKaWYoYSBpbnN0YW5jZW9mIFAudnMpaWYoYS5hPj00KXtk
+PXIuYShlLmMpCmUuYz1udWxsCmExPWUuTjgoZCkKZS5hPWEuYQplLmM9YS5jCmIuYT1hCmNvbnRpbnVl
+fWVsc2UgUC5BOShhLGUpCmVsc2UgZS5lYyhhKQpyZXR1cm59fWU9cC5hLmIKZD1yLmEoZS5jKQplLmM9
+bnVsbAphMT1lLk44KGQpCmE9cC5iCms9cC5jCmlmKCFhKXtlLiR0aS5jLmEoaykKZS5hPTQKZS5jPWt9
+ZWxzZXtzLmEoaykKZS5hPTgKZS5jPWt9Yi5hPWUKYT1lfX0sClZIOmZ1bmN0aW9uKGEsYil7dmFyIHMK
+aWYodC5hZy5iKGEpKXJldHVybiBiLkxqKGEsdC56LHQuSyx0LmwpCnM9dC5iSQppZihzLmIoYSkpcmV0
+dXJuIHMuYShhKQp0aHJvdyBILmIoUC5MMyhhLCJvbkVycm9yIiwiRXJyb3IgaGFuZGxlciBtdXN0IGFj
+Y2VwdCBvbmUgT2JqZWN0IG9yIG9uZSBPYmplY3QgYW5kIGEgU3RhY2tUcmFjZSBhcyBhcmd1bWVudHMs
+IGFuZCByZXR1cm4gYSBhIHZhbGlkIHJlc3VsdCIpKX0sCnB1OmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Io
+cz0kLlM2O3MhPW51bGw7cz0kLlM2KXskLm1nPW51bGwKcj1zLmIKJC5TNj1yCmlmKHI9PW51bGwpJC5r
+OD1udWxsCnMuYS4kMCgpfX0sCmVOOmZ1bmN0aW9uKCl7JC5VRD0hMAp0cnl7UC5wdSgpfWZpbmFsbHl7
+JC5tZz1udWxsCiQuVUQ9ITEKaWYoJC5TNiE9bnVsbCkkLnV0KCkuJDEoUC5VSSgpKX19LAplVzpmdW5j
+dGlvbihhKXt2YXIgcz1uZXcgUC5PTShhKSxyPSQuazgKaWYocj09bnVsbCl7JC5TNj0kLms4PXMKaWYo
+ISQuVUQpJC51dCgpLiQxKFAuVUkoKSl9ZWxzZSAkLms4PXIuYj1zfSwKclI6ZnVuY3Rpb24oYSl7dmFy
+IHMscixxLHA9JC5TNgppZihwPT1udWxsKXtQLmVXKGEpCiQubWc9JC5rOApyZXR1cm59cz1uZXcgUC5P
+TShhKQpyPSQubWcKaWYocj09bnVsbCl7cy5iPXAKJC5TNj0kLm1nPXN9ZWxzZXtxPXIuYgpzLmI9cQok
+Lm1nPXIuYj1zCmlmKHE9PW51bGwpJC5rOD1zfX0sCnJiOmZ1bmN0aW9uKGEpe3ZhciBzPW51bGwscj0k
+LlgzCmlmKEMuTlU9PT1yKXtQLlRrKHMscyxDLk5VLGEpCnJldHVybn1QLlRrKHMscyxyLHQuTS5hKHIu
+dDgoYSkpKX0sClF3OmZ1bmN0aW9uKGEsYil7SC5jYihhLCJzdHJlYW0iLHQuSykKcmV0dXJuIG5ldyBQ
+LnhJKGIuQygieEk8MD4iKSl9LApUbDpmdW5jdGlvbihhLGIpe3ZhciBzPUguY2IoYSwiZXJyb3IiLHQu
+SykKcmV0dXJuIG5ldyBQLkN3KHMsYj09bnVsbD9QLnYwKGEpOmIpfSwKdjA6ZnVuY3Rpb24oYSl7dmFy
+IHMKaWYodC5yLmIoYSkpe3M9YS5nSUkoKQppZihzIT1udWxsKXJldHVybiBzfXJldHVybiBDLnBkfSwK
+TDI6ZnVuY3Rpb24oYSxiLGMsZCxlKXtQLnJSKG5ldyBQLnBLKGQsZSkpfSwKVDg6ZnVuY3Rpb24oYSxi
+LGMsZCxlKXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDAoKQokLlgzPWMKcz1yCnRyeXty
+PWQuJDAoKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LAp5djpmdW5jdGlvbihhLGIsYyxkLGUsZixn
+KXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDEoZSkKJC5YMz1jCnM9cgp0cnl7cj1kLiQx
+KGUpCnJldHVybiByfWZpbmFsbHl7JC5YMz1zfX0sClF4OmZ1bmN0aW9uKGEsYixjLGQsZSxmLGcsaCxp
+KXt2YXIgcyxyPSQuWDMKaWYocj09PWMpcmV0dXJuIGQuJDIoZSxmKQokLlgzPWMKcz1yCnRyeXtyPWQu
+JDIoZSxmKQpyZXR1cm4gcn1maW5hbGx5eyQuWDM9c319LApUazpmdW5jdGlvbihhLGIsYyxkKXt2YXIg
+cwp0Lk0uYShkKQpzPUMuTlUhPT1jCmlmKHMpZD0hKCFzfHwhMSk/Yy50OChkKTpjLlJUKGQsdC5IKQpQ
+LmVXKGQpfSwKdGg6ZnVuY3Rpb24gdGgoYSl7dGhpcy5hPWF9LApoYTpmdW5jdGlvbiBoYShhLGIsYyl7
+dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApWczpmdW5jdGlvbiBWcyhhKXt0aGlzLmE9YX0sCkZ0
+OmZ1bmN0aW9uIEZ0KGEpe3RoaXMuYT1hfSwKVzM6ZnVuY3Rpb24gVzMoKXt9LAp5SDpmdW5jdGlvbiB5
+SChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKaWg6ZnVuY3Rpb24gaWgoYSxiKXt0aGlzLmE9YQp0aGlz
+LmI9ITEKdGhpcy4kdGk9Yn0sCldNOmZ1bmN0aW9uIFdNKGEpe3RoaXMuYT1hfSwKU1g6ZnVuY3Rpb24g
+U1goYSl7dGhpcy5hPWF9LApHczpmdW5jdGlvbiBHcyhhKXt0aGlzLmE9YX0sCkZ5OmZ1bmN0aW9uIEZ5
+KGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApHVjpmdW5jdGlvbiBHVihhLGIpe3ZhciBfPXRoaXMKXy5h
+PWEKXy5kPV8uYz1fLmI9bnVsbApfLiR0aT1ifSwKcTQ6ZnVuY3Rpb24gcTQoYSxiKXt0aGlzLmE9YQp0
+aGlzLiR0aT1ifSwKUGY6ZnVuY3Rpb24gUGYoKXt9LApaZjpmdW5jdGlvbiBaZihhLGIpe3RoaXMuYT1h
+CnRoaXMuJHRpPWJ9LApGZTpmdW5jdGlvbiBGZShhLGIsYyxkLGUpe3ZhciBfPXRoaXMKXy5hPW51bGwK
+Xy5iPWEKXy5jPWIKXy5kPWMKXy5lPWQKXy4kdGk9ZX0sCnZzOmZ1bmN0aW9uIHZzKGEsYil7dmFyIF89
+dGhpcwpfLmE9MApfLmI9YQpfLmM9bnVsbApfLiR0aT1ifSwKZGE6ZnVuY3Rpb24gZGEoYSxiKXt0aGlz
+LmE9YQp0aGlzLmI9Yn0sCm9ROmZ1bmN0aW9uIG9RKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApwVjpm
+dW5jdGlvbiBwVihhKXt0aGlzLmE9YX0sClU3OmZ1bmN0aW9uIFU3KGEpe3RoaXMuYT1hfSwKdnI6ZnVu
+Y3Rpb24gdnIoYSxiLGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKcnQ6ZnVuY3Rpb24gcnQo
+YSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCktGOmZ1bmN0aW9uIEtGKGEsYil7dGhpcy5hPWEKdGhpcy5i
+PWJ9LApaTDpmdW5jdGlvbiBaTChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApSVDpm
+dW5jdGlvbiBSVChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApqWjpmdW5jdGlvbiBq
+WihhKXt0aGlzLmE9YX0sCnJxOmZ1bmN0aW9uIHJxKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApSVzpm
+dW5jdGlvbiBSVyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKT006ZnVuY3Rpb24gT00oYSl7dGhpcy5h
+PWEKdGhpcy5iPW51bGx9LApxaDpmdW5jdGlvbiBxaCgpe30sCkI1OmZ1bmN0aW9uIEI1KGEsYil7dGhp
+cy5hPWEKdGhpcy5iPWJ9LAp1TzpmdW5jdGlvbiB1TyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKTU86
+ZnVuY3Rpb24gTU8oKXt9LAprVDpmdW5jdGlvbiBrVCgpe30sCnhJOmZ1bmN0aW9uIHhJKGEpe3RoaXMu
+JHRpPWF9LApDdzpmdW5jdGlvbiBDdyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKbTA6ZnVuY3Rpb24g
+bTAoKXt9LApwSzpmdW5jdGlvbiBwSyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKSmk6ZnVuY3Rpb24g
+SmkoKXt9LApoajpmdW5jdGlvbiBoaihhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApW
+cDpmdW5jdGlvbiBWcChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKT1I6ZnVuY3Rpb24gT1IoYSxiLGMp
+e3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKRUY6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBiLkMo
+IkA8MD4iKS5LcShjKS5DKCJGbzwxLDI+IikuYShILkI3KGEsbmV3IEguTjUoYi5DKCJAPDA+IikuS3Eo
+YykuQygiTjU8MSwyPiIpKSkpfSwKRmw6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguTjUoYS5DKCJA
+PDA+IikuS3EoYikuQygiTjU8MSwyPiIpKX0sCkxzOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5iNihh
+LkMoImI2PDA+IikpfSwKVDI6ZnVuY3Rpb24oKXt2YXIgcz1PYmplY3QuY3JlYXRlKG51bGwpCnNbIjxu
+b24taWRlbnRpZmllci1rZXk+Il09cwpkZWxldGUgc1siPG5vbi1pZGVudGlmaWVyLWtleT4iXQpyZXR1
+cm4gc30sCnJqOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1uZXcgUC5sbShhLGIsYy5DKCJsbTwwPiIpKQpz
+LmM9YS5lCnJldHVybiBzfSwKRVA6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKaWYoUC5oQihhKSl7aWYo
+Yj09PSIoIiYmYz09PSIpIilyZXR1cm4iKC4uLikiCnJldHVybiBiKyIuLi4iK2N9cz1ILlZNKFtdLHQu
+cykKQy5ObS5pKCQueGcsYSkKdHJ5e1AuVnIoYSxzKX1maW5hbGx5e2lmKDA+PSQueGcubGVuZ3RoKXJl
+dHVybiBILk9IKCQueGcsLTEpCiQueGcucG9wKCl9cj1QLnZnKGIsdC51LmEocyksIiwgIikrYwpyZXR1
+cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn0sCldFOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyCmlmKFAu
+aEIoYSkpcmV0dXJuIGIrIi4uLiIrYwpzPW5ldyBQLlJuKGIpCkMuTm0uaSgkLnhnLGEpCnRyeXtyPXMK
+ci5hPVAudmcoci5hLGEsIiwgIil9ZmluYWxseXtpZigwPj0kLnhnLmxlbmd0aClyZXR1cm4gSC5PSCgk
+LnhnLC0xKQokLnhnLnBvcCgpfXMuYSs9YwpyPXMuYQpyZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6
+cn0sCmhCOmZ1bmN0aW9uKGEpe3ZhciBzLHIKZm9yKHM9JC54Zy5sZW5ndGgscj0wO3I8czsrK3IpaWYo
+YT09PSQueGdbcl0pcmV0dXJuITAKcmV0dXJuITF9LApWcjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxw
+LG8sbixtLGw9YS5nbShhKSxrPTAsaj0wCndoaWxlKCEwKXtpZighKGs8ODB8fGo8MykpYnJlYWsKaWYo
+IWwuRigpKXJldHVybgpzPUguRWoobC5nbCgpKQpDLk5tLmkoYixzKQprKz1zLmxlbmd0aCsyOysran1p
+ZighbC5GKCkpe2lmKGo8PTUpcmV0dXJuCmlmKDA+PWIubGVuZ3RoKXJldHVybiBILk9IKGIsLTEpCnI9
+Yi5wb3AoKQppZigwPj1iLmxlbmd0aClyZXR1cm4gSC5PSChiLC0xKQpxPWIucG9wKCl9ZWxzZXtwPWwu
+Z2woKTsrK2oKaWYoIWwuRigpKXtpZihqPD00KXtDLk5tLmkoYixILkVqKHApKQpyZXR1cm59cj1ILkVq
+KHApCmlmKDA+PWIubGVuZ3RoKXJldHVybiBILk9IKGIsLTEpCnE9Yi5wb3AoKQprKz1yLmxlbmd0aCsy
+fWVsc2V7bz1sLmdsKCk7KytqCmZvcig7bC5GKCk7cD1vLG89bil7bj1sLmdsKCk7KytqCmlmKGo+MTAw
+KXt3aGlsZSghMCl7aWYoIShrPjc1JiZqPjMpKWJyZWFrCmlmKDA+PWIubGVuZ3RoKXJldHVybiBILk9I
+KGIsLTEpCmstPWIucG9wKCkubGVuZ3RoKzI7LS1qfUMuTm0uaShiLCIuLi4iKQpyZXR1cm59fXE9SC5F
+aihwKQpyPUguRWoobykKays9ci5sZW5ndGgrcS5sZW5ndGgrNH19aWYoaj5iLmxlbmd0aCsyKXtrKz01
+Cm09Ii4uLiJ9ZWxzZSBtPW51bGwKd2hpbGUoITApe2lmKCEoaz44MCYmYi5sZW5ndGg+MykpYnJlYWsK
+aWYoMD49Yi5sZW5ndGgpcmV0dXJuIEguT0goYiwtMSkKay09Yi5wb3AoKS5sZW5ndGgrMgppZihtPT1u
+dWxsKXtrKz01Cm09Ii4uLiJ9fWlmKG0hPW51bGwpQy5ObS5pKGIsbSkKQy5ObS5pKGIscSkKQy5ObS5p
+KGIscil9LAp0TTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscT1QLkxzKGIpCmZvcihzPWEubGVuZ3RoLHI9
+MDtyPGEubGVuZ3RoO2EubGVuZ3RoPT09c3x8KDAsSC5saykoYSksKytyKXEuaSgwLGIuYShhW3JdKSkK
+cmV0dXJuIHF9LApuTzpmdW5jdGlvbihhKXt2YXIgcyxyPXt9CmlmKFAuaEIoYSkpcmV0dXJuInsuLi59
+IgpzPW5ldyBQLlJuKCIiKQp0cnl7Qy5ObS5pKCQueGcsYSkKcy5hKz0ieyIKci5hPSEwCmEuSygwLG5l
+dyBQLnJhKHIscykpCnMuYSs9In0ifWZpbmFsbHl7aWYoMD49JC54Zy5sZW5ndGgpcmV0dXJuIEguT0go
+JC54ZywtMSkKJC54Zy5wb3AoKX1yPXMuYQpyZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn0sCmI2
+OmZ1bmN0aW9uIGI2KGEpe3ZhciBfPXRoaXMKXy5hPTAKXy5mPV8uZT1fLmQ9Xy5jPV8uYj1udWxsCl8u
+cj0wCl8uJHRpPWF9LApibjpmdW5jdGlvbiBibihhKXt0aGlzLmE9YQp0aGlzLmM9dGhpcy5iPW51bGx9
+LApsbTpmdW5jdGlvbiBsbShhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmQ9Xy5jPW51bGwK
+Xy4kdGk9Y30sCm1XOmZ1bmN0aW9uIG1XKCl7fSwKdXk6ZnVuY3Rpb24gdXkoKXt9LApsRDpmdW5jdGlv
+biBsRCgpe30sCmlsOmZ1bmN0aW9uIGlsKCl7fSwKcmE6ZnVuY3Rpb24gcmEoYSxiKXt0aGlzLmE9YQp0
+aGlzLmI9Yn0sCllrOmZ1bmN0aW9uIFlrKCl7fSwKeVE6ZnVuY3Rpb24geVEoYSl7dGhpcy5hPWF9LApL
+UDpmdW5jdGlvbiBLUCgpe30sClBuOmZ1bmN0aW9uIFBuKCl7fSwKR2o6ZnVuY3Rpb24gR2ooYSxiKXt0
+aGlzLmE9YQp0aGlzLiR0aT1ifSwKbGY6ZnVuY3Rpb24gbGYoKXt9LApWajpmdW5jdGlvbiBWaigpe30s
+Clh2OmZ1bmN0aW9uIFh2KCl7fSwKblk6ZnVuY3Rpb24gblkoKXt9LApXWTpmdW5jdGlvbiBXWSgpe30s
+ClJVOmZ1bmN0aW9uIFJVKCl7fSwKcFI6ZnVuY3Rpb24gcFIoKXt9LApCUzpmdW5jdGlvbihhLGIpe3Zh
+ciBzLHIscSxwCmlmKHR5cGVvZiBhIT0ic3RyaW5nIil0aHJvdyBILmIoSC50TChhKSkKcz1udWxsCnRy
+eXtzPUpTT04ucGFyc2UoYSl9Y2F0Y2gocSl7cj1ILlJ1KHEpCnA9UC5ycihTdHJpbmcociksbnVsbCxu
+dWxsKQp0aHJvdyBILmIocCl9cD1QLlFlKHMpCnJldHVybiBwfSwKUWU6ZnVuY3Rpb24oYSl7dmFyIHMK
+aWYoYT09bnVsbClyZXR1cm4gbnVsbAppZih0eXBlb2YgYSE9Im9iamVjdCIpcmV0dXJuIGEKaWYoT2Jq
+ZWN0LmdldFByb3RvdHlwZU9mKGEpIT09QXJyYXkucHJvdG90eXBlKXJldHVybiBuZXcgUC51dyhhLE9i
+amVjdC5jcmVhdGUobnVsbCkpCmZvcihzPTA7czxhLmxlbmd0aDsrK3MpYVtzXT1QLlFlKGFbc10pCnJl
+dHVybiBhfSwKa3k6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscgppZihiIGluc3RhbmNlb2YgVWludDhB
+cnJheSl7cz1iCmQ9cy5sZW5ndGgKaWYoZC1jPDE1KXJldHVybiBudWxsCnI9UC5DRyhhLHMsYyxkKQpp
+ZihyIT1udWxsJiZhKWlmKHIuaW5kZXhPZigiXHVmZmZkIik+PTApcmV0dXJuIG51bGwKcmV0dXJuIHJ9
+cmV0dXJuIG51bGx9LApDRzpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz1hPyQuSEcoKTokLnJmKCkKaWYo
+cz09bnVsbClyZXR1cm4gbnVsbAppZigwPT09YyYmZD09PWIubGVuZ3RoKXJldHVybiBQLlJiKHMsYikK
+cmV0dXJuIFAuUmIocyxiLnN1YmFycmF5KGMsUC5qQihjLGQsYi5sZW5ndGgpKSl9LApSYjpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIKdHJ5e3M9YS5kZWNvZGUoYikKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKX1y
+ZXR1cm4gbnVsbH0sCnhNOmZ1bmN0aW9uKGEsYixjLGQsZSxmKXtpZihDLmpuLnpZKGYsNCkhPT0wKXRo
+cm93IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBwYWRkaW5nLCBwYWRkZWQgbGVuZ3RoIG11c3QgYmUg
+bXVsdGlwbGUgb2YgZm91ciwgaXMgIitmLGEsYykpCmlmKGQrZSE9PWYpdGhyb3cgSC5iKFAucnIoIklu
+dmFsaWQgYmFzZTY0IHBhZGRpbmcsICc9JyBub3QgYXQgdGhlIGVuZCIsYSxiKSkKaWYoZT4yKXRocm93
+IEguYihQLnJyKCJJbnZhbGlkIGJhc2U2NCBwYWRkaW5nLCBtb3JlIHRoYW4gdHdvICc9JyBjaGFyYWN0
+ZXJzIixhLGIpKX0sCkd5OmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gbmV3IFAuVWQoYSxiKX0sCk5DOmZ1
+bmN0aW9uKGEpe3JldHVybiBhLkx0KCl9LApVZzpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC50dShh
+LFtdLFAuQ3koKSl9LAp1WDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscj1uZXcgUC5SbigiIikscT1QLlVn
+KHIsYikKcS5pVShhKQpzPXIuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c30sCmo0OmZ1bmN0
+aW9uKGEpe3N3aXRjaChhKXtjYXNlIDY1OnJldHVybiJNaXNzaW5nIGV4dGVuc2lvbiBieXRlIgpjYXNl
+IDY3OnJldHVybiJVbmV4cGVjdGVkIGV4dGVuc2lvbiBieXRlIgpjYXNlIDY5OnJldHVybiJJbnZhbGlk
+IFVURi04IGJ5dGUiCmNhc2UgNzE6cmV0dXJuIk92ZXJsb25nIGVuY29kaW5nIgpjYXNlIDczOnJldHVy
+biJPdXQgb2YgdW5pY29kZSByYW5nZSIKY2FzZSA3NTpyZXR1cm4iRW5jb2RlZCBzdXJyb2dhdGUiCmNh
+c2UgNzc6cmV0dXJuIlVuZmluaXNoZWQgVVRGLTggb2N0ZXQgc2VxdWVuY2UiCmRlZmF1bHQ6cmV0dXJu
+IiJ9fSwKank6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwPWMtYixvPW5ldyBVaW50OEFycmF5KHAp
+CmZvcihzPUouVTYoYSkscj0wO3I8cDsrK3Ipe3E9cy5xKGEsYityKQppZih0eXBlb2YgcSE9PSJudW1i
+ZXIiKXJldHVybiBxLnpNKCkKaWYoKHEmNDI5NDk2NzA0MCk+Pj4wIT09MClxPTI1NQppZihyPj1wKXJl
+dHVybiBILk9IKG8scikKb1tyXT1xfXJldHVybiBvfSwKdXc6ZnVuY3Rpb24gdXcoYSxiKXt0aGlzLmE9
+YQp0aGlzLmI9Ygp0aGlzLmM9bnVsbH0sCmk4OmZ1bmN0aW9uIGk4KGEpe3RoaXMuYT1hfSwKeHI6ZnVu
+Y3Rpb24geHIoKXt9LApOejpmdW5jdGlvbiBOeigpe30sCkNWOmZ1bmN0aW9uIENWKCl7fSwKVTg6ZnVu
+Y3Rpb24gVTgoKXt9LApVazpmdW5jdGlvbiBVaygpe30sCndJOmZ1bmN0aW9uIHdJKCl7fSwKWmk6ZnVu
+Y3Rpb24gWmkoKXt9LApVZDpmdW5jdGlvbiBVZChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKSzg6ZnVu
+Y3Rpb24gSzgoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCmJ5OmZ1bmN0aW9uIGJ5KCl7fSwKb2o6ZnVu
+Y3Rpb24gb2ooYSl7dGhpcy5iPWF9LApNeDpmdW5jdGlvbiBNeChhKXt0aGlzLmE9YX0sClNoOmZ1bmN0
+aW9uIFNoKCl7fSwKdGk6ZnVuY3Rpb24gdGkoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCnR1OmZ1bmN0
+aW9uIHR1KGEsYixjKXt0aGlzLmM9YQp0aGlzLmE9Ygp0aGlzLmI9Y30sCnU1OmZ1bmN0aW9uIHU1KCl7
+fSwKRTM6ZnVuY3Rpb24gRTMoKXt9LApSdzpmdW5jdGlvbiBSdyhhKXt0aGlzLmI9MAp0aGlzLmM9YX0s
+CkdZOmZ1bmN0aW9uIEdZKGEpe3RoaXMuYT1hfSwKYno6ZnVuY3Rpb24gYnooYSl7dGhpcy5hPWEKdGhp
+cy5iPTE2CnRoaXMuYz0wfSwKUUE6ZnVuY3Rpb24oYSxiKXt2YXIgcz1ILkhwKGEsYikKaWYocyE9bnVs
+bClyZXR1cm4gcwp0aHJvdyBILmIoUC5ycihhLG51bGwsbnVsbCkpfSwKb3M6ZnVuY3Rpb24oYSl7aWYo
+YSBpbnN0YW5jZW9mIEguVHApcmV0dXJuIGEudygwKQpyZXR1cm4iSW5zdGFuY2Ugb2YgJyIrSC5FaihI
+Lk0oYSkpKyInIn0sCk84OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9Yz9KLktoKGEsZCk6Si5RaShh
+LGQpCmlmKGEhPT0wJiZiIT1udWxsKWZvcihzPTA7czxyLmxlbmd0aDsrK3MpcltzXT1iCnJldHVybiBy
+fSwKQ0g6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9SC5WTShbXSxjLkMoImpkPDA+IikpCmZvcihzPUou
+SVQoYSk7cy5GKCk7KUMuTm0uaShyLGMuYShzLmdsKCkpKQppZihiKXJldHVybiByCnJldHVybiBKLkVw
+KHIsYyl9LApZMTpmdW5jdGlvbihhLGIsYyl7dmFyIHMKaWYoYilyZXR1cm4gUC5ldihhLGMpCnM9Si5F
+cChQLmV2KGEsYyksYykKcmV0dXJuIHN9LApldjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoQXJyYXku
+aXNBcnJheShhKSlyZXR1cm4gSC5WTShhLnNsaWNlKDApLGIuQygiamQ8MD4iKSkKcz1ILlZNKFtdLGIu
+QygiamQ8MD4iKSkKZm9yKHI9Si5JVChhKTtyLkYoKTspQy5ObS5pKHMsci5nbCgpKQpyZXR1cm4gc30s
+CkFGOmZ1bmN0aW9uKGEsYil7cmV0dXJuIEouekMoUC5DSChhLCExLGIpKX0sCkhNOmZ1bmN0aW9uKGEs
+YixjKXtpZih0LmJtLmIoYSkpcmV0dXJuIEguZncoYSxiLFAuakIoYixjLGEubGVuZ3RoKSkKcmV0dXJu
+IFAuYncoYSxiLGMpfSwKT286ZnVuY3Rpb24oYSl7cmV0dXJuIEguTHcoYSl9LApidzpmdW5jdGlvbihh
+LGIsYyl7dmFyIHMscixxLHAsbz1udWxsCmlmKGI8MCl0aHJvdyBILmIoUC5URShiLDAsYS5sZW5ndGgs
+byxvKSkKcz1jPT1udWxsCmlmKCFzJiZjPGIpdGhyb3cgSC5iKFAuVEUoYyxiLGEubGVuZ3RoLG8sbykp
+CnI9bmV3IEguYTcoYSxhLmxlbmd0aCxILnooYSkuQygiYTc8bEQuRT4iKSkKZm9yKHE9MDtxPGI7Kytx
+KWlmKCFyLkYoKSl0aHJvdyBILmIoUC5URShiLDAscSxvLG8pKQpwPVtdCmlmKHMpZm9yKDtyLkYoKTsp
+cC5wdXNoKHIuZCkKZWxzZSBmb3IocT1iO3E8YzsrK3Epe2lmKCFyLkYoKSl0aHJvdyBILmIoUC5URShj
+LGIscSxvLG8pKQpwLnB1c2goci5kKX1yZXR1cm4gSC5lVChwKX0sCm51OmZ1bmN0aW9uKGEpe3JldHVy
+biBuZXcgSC5WUihhLEgudjQoYSwhMSwhMCwhMSwhMSwhMSkpfSwKdmc6ZnVuY3Rpb24oYSxiLGMpe3Zh
+ciBzPUouSVQoYikKaWYoIXMuRigpKXJldHVybiBhCmlmKGMubGVuZ3RoPT09MCl7ZG8gYSs9SC5Faihz
+LmdsKCkpCndoaWxlKHMuRigpKX1lbHNle2ErPUguRWoocy5nbCgpKQpmb3IoO3MuRigpOylhPWErYytI
+LkVqKHMuZ2woKSl9cmV0dXJuIGF9LApscjpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gbmV3IFAubXAo
+YSxiLGMsZCl9LAp1bzpmdW5jdGlvbigpe3ZhciBzPUguTTAoKQppZihzIT1udWxsKXJldHVybiBQLmhL
+KHMpCnRocm93IEguYihQLkw0KCInVXJpLmJhc2UnIGlzIG5vdCBzdXBwb3J0ZWQiKSl9LAplUDpmdW5j
+dGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbT0iMDEyMzQ1Njc4OUFCQ0RFRiIKaWYoYz09PUMu
+eE0pe3M9JC56NCgpLmIKaWYodHlwZW9mIGIhPSJzdHJpbmciKUgudihILnRMKGIpKQpzPXMudGVzdChi
+KX1lbHNlIHM9ITEKaWYocylyZXR1cm4gYgpILkxoKGMpLkMoIlVrLlMiKS5hKGIpCnI9Yy5nWkUoKS5X
+SihiKQpmb3Iocz1yLmxlbmd0aCxxPTAscD0iIjtxPHM7KytxKXtvPXJbcV0KaWYobzwxMjgpe249bz4+
+PjQKaWYobj49OClyZXR1cm4gSC5PSChhLG4pCm49KGFbbl0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBuPSEx
+CmlmKG4pcCs9SC5MdyhvKQplbHNlIHA9ZCYmbz09PTMyP3ArIisiOnArIiUiK21bbz4+PjQmMTVdK21b
+byYxNV19cmV0dXJuIHAuY2hhckNvZGVBdCgwKT09MD9wOnB9LApHcTpmdW5jdGlvbihhKXt2YXIgcz1N
+YXRoLmFicyhhKSxyPWE8MD8iLSI6IiIKaWYocz49MTAwMClyZXR1cm4iIithCmlmKHM+PTEwMClyZXR1
+cm4gcisiMCIrcwppZihzPj0xMClyZXR1cm4gcisiMDAiK3MKcmV0dXJuIHIrIjAwMCIrc30sClZ4OmZ1
+bmN0aW9uKGEpe2lmKGE+PTEwMClyZXR1cm4iIithCmlmKGE+PTEwKXJldHVybiIwIithCnJldHVybiIw
+MCIrYX0sCmgwOmZ1bmN0aW9uKGEpe2lmKGE+PTEwKXJldHVybiIiK2EKcmV0dXJuIjAiK2F9LApwOmZ1
+bmN0aW9uKGEpe2lmKHR5cGVvZiBhPT0ibnVtYmVyInx8SC5sKGEpfHxudWxsPT1hKXJldHVybiBKLmoo
+YSkKaWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBKU09OLnN0cmluZ2lmeShhKQpyZXR1cm4gUC5v
+cyhhKX0sCmhWOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgUC5DNihhKX0sCnhZOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBuZXcgUC51KCExLG51bGwsbnVsbCxhKX0sCkwzOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gbmV3
+IFAudSghMCxhLGIsYyl9LApNUjpmdW5jdGlvbihhLGIsYyl7cmV0dXJuIGF9LApPNzpmdW5jdGlvbihh
+LGIpe3JldHVybiBuZXcgUC5iSihudWxsLG51bGwsITAsYSxiLCJWYWx1ZSBub3QgaW4gcmFuZ2UiKX0s
+ClRFOmZ1bmN0aW9uKGEsYixjLGQsZSl7cmV0dXJuIG5ldyBQLmJKKGIsYywhMCxhLGQsIkludmFsaWQg
+dmFsdWUiKX0sCndBOmZ1bmN0aW9uKGEsYixjLGQpe2lmKGE8Ynx8YT5jKXRocm93IEguYihQLlRFKGEs
+YixjLGQsbnVsbCkpCnJldHVybiBhfSwKakI6ZnVuY3Rpb24oYSxiLGMpe2lmKDA+YXx8YT5jKXRocm93
+IEguYihQLlRFKGEsMCxjLCJzdGFydCIsbnVsbCkpCmlmKGIhPW51bGwpe2lmKGE+Ynx8Yj5jKXRocm93
+IEguYihQLlRFKGIsYSxjLCJlbmQiLG51bGwpKQpyZXR1cm4gYn1yZXR1cm4gY30sCmsxOmZ1bmN0aW9u
+KGEsYil7aWYoYTwwKXRocm93IEguYihQLlRFKGEsMCxudWxsLGIsbnVsbCkpCnJldHVybiBhfSwKQ2Y6
+ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz1ILnVQKGU9PW51bGw/Si5IbShiKTplKQpyZXR1cm4gbmV3
+IFAuZVkocywhMCxhLGMsIkluZGV4IG91dCBvZiByYW5nZSIpfSwKTDQ6ZnVuY3Rpb24oYSl7cmV0dXJu
+IG5ldyBQLnViKGEpfSwKU1k6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLmRzKGEpfSwKUFY6ZnVuY3Rp
+b24oYSl7cmV0dXJuIG5ldyBQLmxqKGEpfSwKYTQ6ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLlVWKGEp
+fSwKcnI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBuZXcgUC5hRShhLGIsYyl9LApoSzpmdW5jdGlvbihh
+NSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlLGQsYyxiLGEsYTAsYTEsYTIsYTM9bnVs
+bCxhND1hNS5sZW5ndGgKaWYoYTQ+PTUpe3M9KChKLlF6KGE1LDQpXjU4KSozfEMueEIuVyhhNSwwKV4x
+MDB8Qy54Qi5XKGE1LDEpXjk3fEMueEIuVyhhNSwyKV4xMTZ8Qy54Qi5XKGE1LDMpXjk3KT4+PjAKaWYo
+cz09PTApcmV0dXJuIFAuS0QoYTQ8YTQ/Qy54Qi5OaihhNSwwLGE0KTphNSw1LGEzKS5nbFIoKQplbHNl
+IGlmKHM9PT0zMilyZXR1cm4gUC5LRChDLnhCLk5qKGE1LDUsYTQpLDAsYTMpLmdsUigpfXI9UC5POCg4
+LDAsITEsdC5TKQpDLk5tLlk1KHIsMCwwKQpDLk5tLlk1KHIsMSwtMSkKQy5ObS5ZNShyLDIsLTEpCkMu
+Tm0uWTUociw3LC0xKQpDLk5tLlk1KHIsMywwKQpDLk5tLlk1KHIsNCwwKQpDLk5tLlk1KHIsNSxhNCkK
+Qy5ObS5ZNShyLDYsYTQpCmlmKFAuVUIoYTUsMCxhNCwwLHIpPj0xNClDLk5tLlk1KHIsNyxhNCkKcT1y
+WzFdCmlmKHE+PTApaWYoUC5VQihhNSwwLHEsMjAscik9PT0yMClyWzddPXEKcD1yWzJdKzEKbz1yWzNd
+Cm49cls0XQptPXJbNV0KbD1yWzZdCmlmKGw8bSltPWwKaWYobjxwKW49bQplbHNlIGlmKG48PXEpbj1x
+KzEKaWYobzxwKW89bgprPXJbN108MAppZihrKWlmKHA+cSszKXtqPWEzCms9ITF9ZWxzZXtpPW8+MApp
+ZihpJiZvKzE9PT1uKXtqPWEzCms9ITF9ZWxzZXtpZighKG08YTQmJm09PT1uKzImJkoucTAoYTUsIi4u
+IixuKSkpaD1tPm4rMiYmSi5xMChhNSwiLy4uIixtLTMpCmVsc2UgaD0hMAppZihoKXtqPWEzCms9ITF9
+ZWxzZXtpZihxPT09NClpZihKLnEwKGE1LCJmaWxlIiwwKSl7aWYocDw9MCl7aWYoIUMueEIuUWkoYTUs
+Ii8iLG4pKXtnPSJmaWxlOi8vLyIKcz0zfWVsc2V7Zz0iZmlsZTovLyIKcz0yfWE1PWcrQy54Qi5Oaihh
+NSxuLGE0KQpxLT0wCmk9cy0wCm0rPWkKbCs9aQphND1hNS5sZW5ndGgKcD03Cm89NwpuPTd9ZWxzZSBp
+ZihuPT09bSl7KytsCmY9bSsxCmE1PUMueEIuaTcoYTUsbixtLCIvIik7KythNAptPWZ9aj0iZmlsZSJ9
+ZWxzZSBpZihDLnhCLlFpKGE1LCJodHRwIiwwKSl7aWYoaSYmbyszPT09biYmQy54Qi5RaShhNSwiODAi
+LG8rMSkpe2wtPTMKZT1uLTMKbS09MwphNT1DLnhCLmk3KGE1LG8sbiwiIikKYTQtPTMKbj1lfWo9Imh0
+dHAifWVsc2Ugaj1hMwplbHNlIGlmKHE9PT01JiZKLnEwKGE1LCJodHRwcyIsMCkpe2lmKGkmJm8rND09
+PW4mJkoucTAoYTUsIjQ0MyIsbysxKSl7bC09NAplPW4tNAptLT00CmE1PUouZGcoYTUsbyxuLCIiKQph
+NC09MwpuPWV9aj0iaHR0cHMifWVsc2Ugaj1hMwprPSEwfX19ZWxzZSBqPWEzCmlmKGspe2k9YTUubGVu
+Z3RoCmlmKGE0PGkpe2E1PUoubGQoYTUsMCxhNCkKcS09MApwLT0wCm8tPTAKbi09MAptLT0wCmwtPTB9
+cmV0dXJuIG5ldyBQLlVmKGE1LHEscCxvLG4sbSxsLGopfWlmKGo9PW51bGwpaWYocT4wKWo9UC5QaShh
+NSwwLHEpCmVsc2V7aWYocT09PTApe1AuUjMoYTUsMCwiSW52YWxpZCBlbXB0eSBzY2hlbWUiKQpILkJp
+KHUuZyl9aj0iIn1pZihwPjApe2Q9cSszCmM9ZDxwP1AuelIoYTUsZCxwLTEpOiIiCmI9UC5PZShhNSxw
+LG8sITEpCmk9bysxCmlmKGk8bil7YT1ILkhwKEoubGQoYTUsaSxuKSxhMykKYTA9UC53QihhPT1udWxs
+P0gudihQLnJyKCJJbnZhbGlkIHBvcnQiLGE1LGkpKTphLGopfWVsc2UgYTA9YTN9ZWxzZXthMD1hMwpi
+PWEwCmM9IiJ9YTE9UC5rYShhNSxuLG0sYTMsaixiIT1udWxsKQphMj1tPGw/UC5sZShhNSxtKzEsbCxh
+Myk6YTMKcmV0dXJuIG5ldyBQLkRuKGosYyxiLGEwLGExLGEyLGw8YTQ/UC50RyhhNSxsKzEsYTQpOmEz
+KX0sCk10OmZ1bmN0aW9uKGEpe0guaChhKQpyZXR1cm4gUC5rdShhLDAsYS5sZW5ndGgsQy54TSwhMSl9
+LApXWDpmdW5jdGlvbihhKXt2YXIgcz10Lk4KcmV0dXJuIEMuTm0uTjAoSC5WTShhLnNwbGl0KCImIiks
+dC5zKSxQLkZsKHMscyksbmV3IFAubjEoQy54TSksdC5KKX0sCkhoOmZ1bmN0aW9uKGEsYixjKXt2YXIg
+cyxyLHEscCxvLG4sbT0iSVB2NCBhZGRyZXNzIHNob3VsZCBjb250YWluIGV4YWN0bHkgNCBwYXJ0cyIs
+bD0iZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIDAuLjI1NSIsaz1uZXcgUC5jUyhhKSxqPW5l
+dyBVaW50OEFycmF5KDQpCmZvcihzPWIscj1zLHE9MDtzPGM7KytzKXtwPUMueEIuTzIoYSxzKQppZihw
+IT09NDYpe2lmKChwXjQ4KT45KWsuJDIoImludmFsaWQgY2hhcmFjdGVyIixzKX1lbHNle2lmKHE9PT0z
+KWsuJDIobSxzKQpvPVAuUUEoQy54Qi5OaihhLHIscyksbnVsbCkKaWYobz4yNTUpay4kMihsLHIpCm49
+cSsxCmlmKHE+PTQpcmV0dXJuIEguT0goaixxKQpqW3FdPW8Kcj1zKzEKcT1ufX1pZihxIT09MylrLiQy
+KG0sYykKbz1QLlFBKEMueEIuTmooYSxyLGMpLG51bGwpCmlmKG8+MjU1KWsuJDIobCxyKQppZihxPj00
+KXJldHVybiBILk9IKGoscSkKaltxXT1vCnJldHVybiBqfSwKZWc6ZnVuY3Rpb24oYSxiLGEwKXt2YXIg
+cyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZD1uZXcgUC5WQyhhKSxjPW5ldyBQLkpUKGQsYSkK
+aWYoYS5sZW5ndGg8MilkLiQxKCJhZGRyZXNzIGlzIHRvbyBzaG9ydCIpCnM9SC5WTShbXSx0LmEpCmZv
+cihyPWIscT1yLHA9ITEsbz0hMTtyPGEwOysrcil7bj1DLnhCLk8yKGEscikKaWYobj09PTU4KXtpZihy
+PT09Yil7KytyCmlmKEMueEIuTzIoYSxyKSE9PTU4KWQuJDIoImludmFsaWQgc3RhcnQgY29sb24uIixy
+KQpxPXJ9aWYocj09PXEpe2lmKHApZC4kMigib25seSBvbmUgd2lsZGNhcmQgYDo6YCBpcyBhbGxvd2Vk
+IixyKQpDLk5tLmkocywtMSkKcD0hMH1lbHNlIEMuTm0uaShzLGMuJDIocSxyKSkKcT1yKzF9ZWxzZSBp
+ZihuPT09NDYpbz0hMH1pZihzLmxlbmd0aD09PTApZC4kMSgidG9vIGZldyBwYXJ0cyIpCm09cT09PWEw
+Cmw9Qy5ObS5ncloocykKaWYobSYmbCE9PS0xKWQuJDIoImV4cGVjdGVkIGEgcGFydCBhZnRlciBsYXN0
+IGA6YCIsYTApCmlmKCFtKWlmKCFvKUMuTm0uaShzLGMuJDIocSxhMCkpCmVsc2V7az1QLkhoKGEscSxh
+MCkKQy5ObS5pKHMsKGtbMF08PDh8a1sxXSk+Pj4wKQpDLk5tLmkocywoa1syXTw8OHxrWzNdKT4+PjAp
+fWlmKHApe2lmKHMubGVuZ3RoPjcpZC4kMSgiYW4gYWRkcmVzcyB3aXRoIGEgd2lsZGNhcmQgbXVzdCBo
+YXZlIGxlc3MgdGhhbiA3IHBhcnRzIil9ZWxzZSBpZihzLmxlbmd0aCE9PTgpZC4kMSgiYW4gYWRkcmVz
+cyB3aXRob3V0IGEgd2lsZGNhcmQgbXVzdCBjb250YWluIGV4YWN0bHkgOCBwYXJ0cyIpCmo9bmV3IFVp
+bnQ4QXJyYXkoMTYpCmZvcihsPXMubGVuZ3RoLGk9OS1sLHI9MCxoPTA7cjxsOysrcil7Zz1zW3JdCmlm
+KGc9PT0tMSlmb3IoZj0wO2Y8aTsrK2Ype2lmKGg8MHx8aD49MTYpcmV0dXJuIEguT0goaixoKQpqW2hd
+PTAKZT1oKzEKaWYoZT49MTYpcmV0dXJuIEguT0goaixlKQpqW2VdPTAKaCs9Mn1lbHNle2U9Qy5qbi53
+RyhnLDgpCmlmKGg8MHx8aD49MTYpcmV0dXJuIEguT0goaixoKQpqW2hdPWUKZT1oKzEKaWYoZT49MTYp
+cmV0dXJuIEguT0goaixlKQpqW2VdPWcmMjU1CmgrPTJ9fXJldHVybiBqfSwKS0w6ZnVuY3Rpb24oYSxi
+LGMsZCxlLGYsZyl7dmFyIHMscixxLHAsbyxuCmY9Zj09bnVsbD8iIjpQLlBpKGYsMCxmLmxlbmd0aCkK
+Zz1QLnpSKGcsMCxnPT1udWxsPzA6Zy5sZW5ndGgpCmE9UC5PZShhLDAsYT09bnVsbD8wOmEubGVuZ3Ro
+LCExKQpzPVAubGUobnVsbCwwLDAsZSkKcj1QLnRHKG51bGwsMCwwKQpkPVAud0IoZCxmKQpxPWY9PT0i
+ZmlsZSIKaWYoYT09bnVsbClwPWcubGVuZ3RoIT09MHx8ZCE9bnVsbHx8cQplbHNlIHA9ITEKaWYocClh
+PSIiCnA9YT09bnVsbApvPSFwCmI9UC5rYShiLDAsYj09bnVsbD8wOmIubGVuZ3RoLGMsZixvKQpuPWYu
+bGVuZ3RoPT09MAppZihuJiZwJiYhQy54Qi5uQyhiLCIvIikpYj1QLndGKGIsIW58fG8pCmVsc2UgYj1Q
+LnhlKGIpCnJldHVybiBuZXcgUC5EbihmLGcscCYmQy54Qi5uQyhiLCIvLyIpPyIiOmEsZCxiLHMscil9
+LAp3SzpmdW5jdGlvbihhKXtpZihhPT09Imh0dHAiKXJldHVybiA4MAppZihhPT09Imh0dHBzIilyZXR1
+cm4gNDQzCnJldHVybiAwfSwKUjM6ZnVuY3Rpb24oYSxiLGMpe3Rocm93IEguYihQLnJyKGMsYSxiKSl9
+LApYZDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGg9bnVsbCxnPWIu
+bGVuZ3RoCmlmKGchPT0wKXtxPTAKd2hpbGUoITApe2lmKCEocTxnKSl7cz0iIgpyPTAKYnJlYWt9aWYo
+Qy54Qi5XKGIscSk9PT02NCl7cz1DLnhCLk5qKGIsMCxxKQpyPXErMQpicmVha30rK3F9aWYocjxnJiZD
+LnhCLlcoYixyKT09PTkxKXtmb3IocD1yLG89LTE7cDxnOysrcCl7bj1DLnhCLlcoYixwKQppZihuPT09
+MzcmJm88MCl7bT1DLnhCLlFpKGIsIjI1IixwKzEpP3ArMjpwCm89cApwPW19ZWxzZSBpZihuPT09OTMp
+YnJlYWt9aWYocD09PWcpdGhyb3cgSC5iKFAucnIoIkludmFsaWQgSVB2NiBob3N0IGVudHJ5LiIsYixy
+KSkKbD1vPDA/cDpvClAuZWcoYixyKzEsbCk7KytwCmlmKHAhPT1nJiZDLnhCLlcoYixwKSE9PTU4KXRo
+cm93IEguYihQLnJyKCJJbnZhbGlkIGVuZCBvZiBhdXRob3JpdHkiLGIscCkpfWVsc2UgcD1yCndoaWxl
+KCEwKXtpZighKHA8Zykpe2s9aApicmVha31pZihDLnhCLlcoYixwKT09PTU4KXtqPUMueEIueW4oYixw
+KzEpCms9ai5sZW5ndGghPT0wP1AuUUEoaixoKTpoCmJyZWFrfSsrcH1pPUMueEIuTmooYixyLHApfWVs
+c2V7az1oCmk9awpzPSIifXJldHVybiBQLktMKGksaCxILlZNKGMuc3BsaXQoIi8iKSx0LnMpLGssZCxh
+LHMpfSwKa0U6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCmZvcihzPWEubGVuZ3RoLHI9MDtyPHM7
+KytyKXtxPWFbcl0KcS50b1N0cmluZwpwPUouVTYocSkKbz1wLmdBKHEpCmlmKDA+bylILnYoUC5URSgw
+LDAscC5nQShxKSxudWxsLG51bGwpKQppZihILlNRKHEsIi8iLDApKXtzPVAuTDQoIklsbGVnYWwgcGF0
+aCBjaGFyYWN0ZXIgIitILkVqKHEpKQp0aHJvdyBILmIocyl9fX0sCkhOOmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcyxyLHEKZm9yKHM9SC5xQyhhLGMsbnVsbCxILnQ2KGEpLmMpLHM9bmV3IEguYTcocyxzLmdBKHMp
+LHMuJHRpLkMoImE3PGFMLkU+IikpO3MuRigpOyl7cj1zLmQKcT1QLm51KCdbIiovOjw+P1xcXFx8XScp
+CnIudG9TdHJpbmcKaWYoSC5TUShyLHEsMCkpe3M9UC5MNCgiSWxsZWdhbCBjaGFyYWN0ZXIgaW4gcGF0
+aDogIityKQp0aHJvdyBILmIocyl9fX0sCnJnOmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoISg2NTw9YSYm
+YTw9OTApKXM9OTc8PWEmJmE8PTEyMgplbHNlIHM9ITAKaWYocylyZXR1cm4Kcz1QLkw0KCJJbGxlZ2Fs
+IGRyaXZlIGxldHRlciAiK1AuT28oYSkpCnRocm93IEguYihzKX0sCndCOmZ1bmN0aW9uKGEsYil7aWYo
+YSE9bnVsbCYmYT09PVAud0soYikpcmV0dXJuIG51bGwKcmV0dXJuIGF9LApPZTpmdW5jdGlvbihhLGIs
+YyxkKXt2YXIgcyxyLHEscCxvLG4KaWYoYT09bnVsbClyZXR1cm4gbnVsbAppZihiPT09YylyZXR1cm4i
+IgppZihDLnhCLk8yKGEsYik9PT05MSl7cz1jLTEKaWYoQy54Qi5PMihhLHMpIT09OTMpe1AuUjMoYSxi
+LCJNaXNzaW5nIGVuZCBgXWAgdG8gbWF0Y2ggYFtgIGluIGhvc3QiKQpILkJpKHUuZyl9cj1iKzEKcT1Q
+LnRvKGEscixzKQppZihxPHMpe3A9cSsxCm89UC5PQShhLEMueEIuUWkoYSwiMjUiLHApP3ErMzpwLHMs
+IiUyNSIpfWVsc2Ugbz0iIgpQLmVnKGEscixxKQpyZXR1cm4gQy54Qi5OaihhLGIscSkudG9Mb3dlckNh
+c2UoKStvKyJdIn1mb3Iobj1iO248YzsrK24paWYoQy54Qi5PMihhLG4pPT09NTgpe3E9Qy54Qi5YVShh
+LCIlIixiKQpxPXE+PWImJnE8Yz9xOmMKaWYocTxjKXtwPXErMQpvPVAuT0EoYSxDLnhCLlFpKGEsIjI1
+IixwKT9xKzM6cCxjLCIlMjUiKX1lbHNlIG89IiIKUC5lZyhhLGIscSkKcmV0dXJuIlsiK0MueEIuTmoo
+YSxiLHEpK28rIl0ifXJldHVybiBQLk9MKGEsYixjKX0sCnRvOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1D
+LnhCLlhVKGEsIiUiLGIpCnJldHVybiBzPj1iJiZzPGM/czpjfSwKT0E6ZnVuY3Rpb24oYSxiLGMsZCl7
+dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaT1kIT09IiI/bmV3IFAuUm4oZCk6bnVsbApmb3Iocz1iLHI9
+cyxxPSEwO3M8Yzspe3A9Qy54Qi5PMihhLHMpCmlmKHA9PT0zNyl7bz1QLnJ2KGEscywhMCkKbj1vPT1u
+dWxsCmlmKG4mJnEpe3MrPTMKY29udGludWV9aWYoaT09bnVsbClpPW5ldyBQLlJuKCIiKQptPWkuYSs9
+Qy54Qi5OaihhLHIscykKaWYobilvPUMueEIuTmooYSxzLHMrMykKZWxzZSBpZihvPT09IiUiKXtQLlIz
+KGEscywiWm9uZUlEIHNob3VsZCBub3QgY29udGFpbiAlIGFueW1vcmUiKQpILkJpKHUuZyl9aS5hPW0r
+bwpzKz0zCnI9cwpxPSEwfWVsc2V7aWYocDwxMjcpe249cD4+PjQKaWYobj49OClyZXR1cm4gSC5PSChD
+LkYzLG4pCm49KEMuRjNbbl0mMTw8KHAmMTUpKSE9PTB9ZWxzZSBuPSExCmlmKG4pe2lmKHEmJjY1PD1w
+JiY5MD49cCl7aWYoaT09bnVsbClpPW5ldyBQLlJuKCIiKQppZihyPHMpe2kuYSs9Qy54Qi5OaihhLHIs
+cykKcj1zfXE9ITF9KytzfWVsc2V7aWYoKHAmNjQ1MTIpPT09NTUyOTYmJnMrMTxjKXtsPUMueEIuTzIo
+YSxzKzEpCmlmKChsJjY0NTEyKT09PTU2MzIwKXtwPShwJjEwMjMpPDwxMHxsJjEwMjN8NjU1MzYKaz0y
+fWVsc2Ugaz0xfWVsc2Ugaz0xCmo9Qy54Qi5OaihhLHIscykKaWYoaT09bnVsbCl7aT1uZXcgUC5Sbigi
+IikKbj1pfWVsc2Ugbj1pCm4uYSs9agpuLmErPVAuelgocCkKcys9awpyPXN9fX1pZihpPT1udWxsKXJl
+dHVybiBDLnhCLk5qKGEsYixjKQppZihyPGMpaS5hKz1DLnhCLk5qKGEscixjKQpuPWkuYQpyZXR1cm4g
+bi5jaGFyQ29kZUF0KDApPT0wP246bn0sCk9MOmZ1bmN0aW9uKGEsYixjKXt2YXIgcyxyLHEscCxvLG4s
+bSxsLGssaixpCmZvcihzPWIscj1zLHE9bnVsbCxwPSEwO3M8Yzspe289Qy54Qi5PMihhLHMpCmlmKG89
+PT0zNyl7bj1QLnJ2KGEscywhMCkKbT1uPT1udWxsCmlmKG0mJnApe3MrPTMKY29udGludWV9aWYocT09
+bnVsbClxPW5ldyBQLlJuKCIiKQpsPUMueEIuTmooYSxyLHMpCms9cS5hKz0hcD9sLnRvTG93ZXJDYXNl
+KCk6bAppZihtKXtuPUMueEIuTmooYSxzLHMrMykKaj0zfWVsc2UgaWYobj09PSIlIil7bj0iJTI1Igpq
+PTF9ZWxzZSBqPTMKcS5hPWsrbgpzKz1qCnI9cwpwPSEwfWVsc2V7aWYobzwxMjcpe209bz4+PjQKaWYo
+bT49OClyZXR1cm4gSC5PSChDLmVhLG0pCm09KEMuZWFbbV0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSEx
+CmlmKG0pe2lmKHAmJjY1PD1vJiY5MD49byl7aWYocT09bnVsbClxPW5ldyBQLlJuKCIiKQppZihyPHMp
+e3EuYSs9Qy54Qi5OaihhLHIscykKcj1zfXA9ITF9KytzfWVsc2V7aWYobzw9OTMpe209bz4+PjQKaWYo
+bT49OClyZXR1cm4gSC5PSChDLmFrLG0pCm09KEMuYWtbbV0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBtPSEx
+CmlmKG0pe1AuUjMoYSxzLCJJbnZhbGlkIGNoYXJhY3RlciIpCkguQmkodS5nKX1lbHNle2lmKChvJjY0
+NTEyKT09PTU1Mjk2JiZzKzE8Yyl7aT1DLnhCLk8yKGEscysxKQppZigoaSY2NDUxMik9PT01NjMyMCl7
+bz0obyYxMDIzKTw8MTB8aSYxMDIzfDY1NTM2Cmo9Mn1lbHNlIGo9MX1lbHNlIGo9MQpsPUMueEIuTmoo
+YSxyLHMpCmlmKCFwKWw9bC50b0xvd2VyQ2FzZSgpCmlmKHE9PW51bGwpe3E9bmV3IFAuUm4oIiIpCm09
+cX1lbHNlIG09cQptLmErPWwKbS5hKz1QLnpYKG8pCnMrPWoKcj1zfX19fWlmKHE9PW51bGwpcmV0dXJu
+IEMueEIuTmooYSxiLGMpCmlmKHI8Yyl7bD1DLnhCLk5qKGEscixjKQpxLmErPSFwP2wudG9Mb3dlckNh
+c2UoKTpsfW09cS5hCnJldHVybiBtLmNoYXJDb2RlQXQoMCk9PTA/bTptfSwKUGk6ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBzLHIscSxwLG89dS5nCmlmKGI9PT1jKXJldHVybiIiCmlmKCFQLkV0KEouclkoYSkuVyhh
+LGIpKSl7UC5SMyhhLGIsIlNjaGVtZSBub3Qgc3RhcnRpbmcgd2l0aCBhbHBoYWJldGljIGNoYXJhY3Rl
+ciIpCkguQmkobyl9Zm9yKHM9YixyPSExO3M8YzsrK3Mpe3E9Qy54Qi5XKGEscykKaWYocTwxMjgpe3A9
+cT4+PjQKaWYocD49OClyZXR1cm4gSC5PSChDLm1LLHApCnA9KEMubUtbcF0mMTw8KHEmMTUpKSE9PTB9
+ZWxzZSBwPSExCmlmKCFwKXtQLlIzKGEscywiSWxsZWdhbCBzY2hlbWUgY2hhcmFjdGVyIikKSC5CaShv
+KX1pZig2NTw9cSYmcTw9OTApcj0hMH1hPUMueEIuTmooYSxiLGMpCnJldHVybiBQLllhKHI/YS50b0xv
+d2VyQ2FzZSgpOmEpfSwKWWE6ZnVuY3Rpb24oYSl7aWYoYT09PSJodHRwIilyZXR1cm4iaHR0cCIKaWYo
+YT09PSJmaWxlIilyZXR1cm4iZmlsZSIKaWYoYT09PSJodHRwcyIpcmV0dXJuImh0dHBzIgppZihhPT09
+InBhY2thZ2UiKXJldHVybiJwYWNrYWdlIgpyZXR1cm4gYX0sCnpSOmZ1bmN0aW9uKGEsYixjKXtpZihh
+PT1udWxsKXJldHVybiIiCnJldHVybiBQLlBJKGEsYixjLEMudG8sITEpfSwKa2E6ZnVuY3Rpb24oYSxi
+LGMsZCxlLGYpe3ZhciBzLHIscT1lPT09ImZpbGUiLHA9cXx8ZgppZihhPT1udWxsKXtpZihkPT1udWxs
+KXJldHVybiBxPyIvIjoiIgpzPUgudDYoZCkKcj1uZXcgSC5sSihkLHMuQygicVUoMSkiKS5hKG5ldyBQ
+LlJaKCkpLHMuQygibEo8MSxxVT4iKSkuaygwLCIvIil9ZWxzZSBpZihkIT1udWxsKXRocm93IEguYihQ
+LnhZKCJCb3RoIHBhdGggYW5kIHBhdGhTZWdtZW50cyBzcGVjaWZpZWQiKSkKZWxzZSByPVAuUEkoYSxi
+LGMsQy5XZCwhMCkKaWYoci5sZW5ndGg9PT0wKXtpZihxKXJldHVybiIvIn1lbHNlIGlmKHAmJiFDLnhC
+Lm5DKHIsIi8iKSlyPSIvIityCnJldHVybiBQLkpyKHIsZSxmKX0sCkpyOmZ1bmN0aW9uKGEsYixjKXt2
+YXIgcz1iLmxlbmd0aD09PTAKaWYocyYmIWMmJiFDLnhCLm5DKGEsIi8iKSlyZXR1cm4gUC53RihhLCFz
+fHxjKQpyZXR1cm4gUC54ZShhKX0sCmxlOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9e30KaWYoYSE9
+bnVsbCl7aWYoZCE9bnVsbCl0aHJvdyBILmIoUC54WSgiQm90aCBxdWVyeSBhbmQgcXVlcnlQYXJhbWV0
+ZXJzIHNwZWNpZmllZCIpKQpyZXR1cm4gUC5QSShhLGIsYyxDLlZDLCEwKX1pZihkPT1udWxsKXJldHVy
+biBudWxsCnM9bmV3IFAuUm4oIiIpCnIuYT0iIgpkLksoMCxuZXcgUC55NShuZXcgUC5NRShyLHMpKSkK
+cj1zLmEKcmV0dXJuIHIuY2hhckNvZGVBdCgwKT09MD9yOnJ9LAp0RzpmdW5jdGlvbihhLGIsYyl7aWYo
+YT09bnVsbClyZXR1cm4gbnVsbApyZXR1cm4gUC5QSShhLGIsYyxDLlZDLCEwKX0sCnJ2OmZ1bmN0aW9u
+KGEsYixjKXt2YXIgcyxyLHEscCxvLG49YisyCmlmKG4+PWEubGVuZ3RoKXJldHVybiIlIgpzPUMueEIu
+TzIoYSxiKzEpCnI9Qy54Qi5PMihhLG4pCnE9SC5vbyhzKQpwPUgub28ocikKaWYocTwwfHxwPDApcmV0
+dXJuIiUiCm89cSoxNitwCmlmKG88MTI3KXtuPUMuam4ud0cobyw0KQppZihuPj04KXJldHVybiBILk9I
+KEMuRjMsbikKbj0oQy5GM1tuXSYxPDwobyYxNSkpIT09MH1lbHNlIG49ITEKaWYobilyZXR1cm4gSC5M
+dyhjJiY2NTw9byYmOTA+PW8/KG98MzIpPj4+MDpvKQppZihzPj05N3x8cj49OTcpcmV0dXJuIEMueEIu
+TmooYSxiLGIrMykudG9VcHBlckNhc2UoKQpyZXR1cm4gbnVsbH0sCnpYOmZ1bmN0aW9uKGEpe3ZhciBz
+LHIscSxwLG8sbixtLGwsaz0iMDEyMzQ1Njc4OUFCQ0RFRiIKaWYoYTwxMjgpe3M9bmV3IFVpbnQ4QXJy
+YXkoMykKc1swXT0zNwpzWzFdPUMueEIuVyhrLGE+Pj40KQpzWzJdPUMueEIuVyhrLGEmMTUpfWVsc2V7
+aWYoYT4yMDQ3KWlmKGE+NjU1MzUpe3I9MjQwCnE9NH1lbHNle3I9MjI0CnE9M31lbHNle3I9MTkyCnE9
+Mn1wPTMqcQpzPW5ldyBVaW50OEFycmF5KHApCmZvcihvPTA7LS1xLHE+PTA7cj0xMjgpe249Qy5qbi5i
+ZihhLDYqcSkmNjN8cgppZihvPj1wKXJldHVybiBILk9IKHMsbykKc1tvXT0zNwptPW8rMQpsPUMueEIu
+VyhrLG4+Pj40KQppZihtPj1wKXJldHVybiBILk9IKHMsbSkKc1ttXT1sCmw9bysyCm09Qy54Qi5XKGss
+biYxNSkKaWYobD49cClyZXR1cm4gSC5PSChzLGwpCnNbbF09bQpvKz0zfX1yZXR1cm4gUC5ITShzLDAs
+bnVsbCl9LApQSTpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzPVAuVWwoYSxiLGMsZCxlKQpyZXR1cm4g
+cz09bnVsbD9DLnhCLk5qKGEsYixjKTpzfSwKVWw6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEs
+cCxvLG4sbSxsLGssaj1udWxsCmZvcihzPSFlLHI9YixxPXIscD1qO3I8Yzspe289Qy54Qi5PMihhLHIp
+CmlmKG88MTI3KXtuPW8+Pj40CmlmKG4+PTgpcmV0dXJuIEguT0goZCxuKQpuPShkW25dJjE8PChvJjE1
+KSkhPT0wfWVsc2Ugbj0hMQppZihuKSsrcgplbHNle2lmKG89PT0zNyl7bT1QLnJ2KGEsciwhMSkKaWYo
+bT09bnVsbCl7cis9Mwpjb250aW51ZX1pZigiJSI9PT1tKXttPSIlMjUiCmw9MX1lbHNlIGw9M31lbHNl
+e2lmKHMpaWYobzw9OTMpe249bz4+PjQKaWYobj49OClyZXR1cm4gSC5PSChDLmFrLG4pCm49KEMuYWtb
+bl0mMTw8KG8mMTUpKSE9PTB9ZWxzZSBuPSExCmVsc2Ugbj0hMQppZihuKXtQLlIzKGEsciwiSW52YWxp
+ZCBjaGFyYWN0ZXIiKQpILkJpKHUuZykKbD1qCm09bH1lbHNle2lmKChvJjY0NTEyKT09PTU1Mjk2KXtu
+PXIrMQppZihuPGMpe2s9Qy54Qi5PMihhLG4pCmlmKChrJjY0NTEyKT09PTU2MzIwKXtvPShvJjEwMjMp
+PDwxMHxrJjEwMjN8NjU1MzYKbD0yfWVsc2UgbD0xfWVsc2UgbD0xfWVsc2UgbD0xCm09UC56WChvKX19
+aWYocD09bnVsbCl7cD1uZXcgUC5SbigiIikKbj1wfWVsc2Ugbj1wCm4uYSs9Qy54Qi5OaihhLHEscikK
+bi5hKz1ILkVqKG0pCmlmKHR5cGVvZiBsIT09Im51bWJlciIpcmV0dXJuIEgucFkobCkKcis9bApxPXJ9
+fWlmKHA9PW51bGwpcmV0dXJuIGoKaWYocTxjKXAuYSs9Qy54Qi5OaihhLHEsYykKcz1wLmEKcmV0dXJu
+IHMuY2hhckNvZGVBdCgwKT09MD9zOnN9LAp5QjpmdW5jdGlvbihhKXtpZihDLnhCLm5DKGEsIi4iKSly
+ZXR1cm4hMApyZXR1cm4gQy54Qi5PWShhLCIvLiIpIT09LTF9LAp4ZTpmdW5jdGlvbihhKXt2YXIgcyxy
+LHEscCxvLG4sbQppZighUC55QihhKSlyZXR1cm4gYQpzPUguVk0oW10sdC5zKQpmb3Iocj1hLnNwbGl0
+KCIvIikscT1yLmxlbmd0aCxwPSExLG89MDtvPHE7KytvKXtuPXJbb10KaWYoSi5STShuLCIuLiIpKXtt
+PXMubGVuZ3RoCmlmKG0hPT0wKXtpZigwPj1tKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKaWYocy5s
+ZW5ndGg9PT0wKUMuTm0uaShzLCIiKX1wPSEwfWVsc2UgaWYoIi4iPT09bilwPSEwCmVsc2V7Qy5ObS5p
+KHMsbikKcD0hMX19aWYocClDLk5tLmkocywiIikKcmV0dXJuIEMuTm0uayhzLCIvIil9LAp3RjpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbgppZighUC55QihhKSlyZXR1cm4hYj9QLkMxKGEpOmEKcz1I
+LlZNKFtdLHQucykKZm9yKHI9YS5zcGxpdCgiLyIpLHE9ci5sZW5ndGgscD0hMSxvPTA7bzxxOysrbyl7
+bj1yW29dCmlmKCIuLiI9PT1uKWlmKHMubGVuZ3RoIT09MCYmQy5ObS5ncloocykhPT0iLi4iKXtpZigw
+Pj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnA9ITB9ZWxzZXtDLk5tLmkocywiLi4i
+KQpwPSExfWVsc2UgaWYoIi4iPT09bilwPSEwCmVsc2V7Qy5ObS5pKHMsbikKcD0hMX19cj1zLmxlbmd0
+aAppZihyIT09MClpZihyPT09MSl7aWYoMD49cilyZXR1cm4gSC5PSChzLDApCnI9c1swXS5sZW5ndGg9
+PT0wfWVsc2Ugcj0hMQplbHNlIHI9ITAKaWYocilyZXR1cm4iLi8iCmlmKHB8fEMuTm0uZ3JaKHMpPT09
+Ii4uIilDLk5tLmkocywiIikKaWYoIWIpe2lmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsMCkKQy5O
+bS5ZNShzLDAsUC5DMShzWzBdKSl9cmV0dXJuIEMuTm0uayhzLCIvIil9LApDMTpmdW5jdGlvbihhKXt2
+YXIgcyxyLHEscD1hLmxlbmd0aAppZihwPj0yJiZQLkV0KEouUXooYSwwKSkpZm9yKHM9MTtzPHA7Kytz
+KXtyPUMueEIuVyhhLHMpCmlmKHI9PT01OClyZXR1cm4gQy54Qi5OaihhLDAscykrIiUzQSIrQy54Qi55
+bihhLHMrMSkKaWYocjw9MTI3KXtxPXI+Pj40CmlmKHE+PTgpcmV0dXJuIEguT0goQy5tSyxxKQpxPShD
+Lm1LW3FdJjE8PChyJjE1KSk9PT0wfWVsc2UgcT0hMAppZihxKWJyZWFrfXJldHVybiBhfSwKbW46ZnVu
+Y3Rpb24oYSl7dmFyIHMscixxLHA9YS5nRmooKSxvPXAubGVuZ3RoCmlmKG8+MCYmSi5IbShwWzBdKT09
+PTImJkouYTYocFswXSwxKT09PTU4KXtpZigwPj1vKXJldHVybiBILk9IKHAsMCkKUC5yZyhKLmE2KHBb
+MF0sMCksITEpClAuSE4ocCwhMSwxKQpzPSEwfWVsc2V7UC5ITihwLCExLDApCnM9ITF9cj1hLmd0VCgp
+JiYhcz8iXFwiOiIiCmlmKGEuZ2NqKCkpe3E9YS5nSmYoYSkKaWYocS5sZW5ndGghPT0wKXI9cisiXFwi
+K3ErIlxcIn1yPVAudmcocixwLCJcXCIpCm89cyYmbz09PTE/cisiXFwiOnIKcmV0dXJuIG8uY2hhckNv
+ZGVBdCgwKT09MD9vOm99LApJaDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpmb3Iocz0wLHI9MDtyPDI7
+KytyKXtxPUMueEIuVyhhLGIrcikKaWYoNDg8PXEmJnE8PTU3KXM9cyoxNitxLTQ4CmVsc2V7cXw9MzIK
+aWYoOTc8PXEmJnE8PTEwMilzPXMqMTYrcS04NwplbHNlIHRocm93IEguYihQLnhZKCJJbnZhbGlkIFVS
+TCBlbmNvZGluZyIpKX19cmV0dXJuIHN9LAprdTpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBzLHIscSxw
+LG89Si5yWShhKSxuPWIKd2hpbGUoITApe2lmKCEobjxjKSl7cz0hMApicmVha31yPW8uVyhhLG4pCmlm
+KHI8PTEyNylpZihyIT09MzcpcT1lJiZyPT09NDMKZWxzZSBxPSEwCmVsc2UgcT0hMAppZihxKXtzPSEx
+CmJyZWFrfSsrbn1pZihzKXtpZihDLnhNIT09ZClxPSExCmVsc2UgcT0hMAppZihxKXJldHVybiBvLk5q
+KGEsYixjKQplbHNlIHA9bmV3IEgucWooby5OaihhLGIsYykpfWVsc2V7cD1ILlZNKFtdLHQuYSkKZm9y
+KG49YjtuPGM7KytuKXtyPW8uVyhhLG4pCmlmKHI+MTI3KXRocm93IEguYihQLnhZKCJJbGxlZ2FsIHBl
+cmNlbnQgZW5jb2RpbmcgaW4gVVJJIikpCmlmKHI9PT0zNyl7aWYobiszPmEubGVuZ3RoKXRocm93IEgu
+YihQLnhZKCJUcnVuY2F0ZWQgVVJJIikpCkMuTm0uaShwLFAuSWgoYSxuKzEpKQpuKz0yfWVsc2UgaWYo
+ZSYmcj09PTQzKUMuTm0uaShwLDMyKQplbHNlIEMuTm0uaShwLHIpfX10LkwuYShwKQpyZXR1cm4gQy5v
+RS5XSihwKX0sCkV0OmZ1bmN0aW9uKGEpe3ZhciBzPWF8MzIKcmV0dXJuIDk3PD1zJiZzPD0xMjJ9LApL
+RDpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbCxrPSJJbnZhbGlkIE1JTUUgdHlwZSIs
+aj1ILlZNKFtiLTFdLHQuYSkKZm9yKHM9YS5sZW5ndGgscj1iLHE9LTEscD1udWxsO3I8czsrK3Ipe3A9
+Qy54Qi5XKGEscikKaWYocD09PTQ0fHxwPT09NTkpYnJlYWsKaWYocD09PTQ3KXtpZihxPDApe3E9cgpj
+b250aW51ZX10aHJvdyBILmIoUC5ycihrLGEscikpfX1pZihxPDAmJnI+Yil0aHJvdyBILmIoUC5ycihr
+LGEscikpCmZvcig7cCE9PTQ0Oyl7Qy5ObS5pKGoscik7KytyCmZvcihvPS0xO3I8czsrK3Ipe3A9Qy54
+Qi5XKGEscikKaWYocD09PTYxKXtpZihvPDApbz1yfWVsc2UgaWYocD09PTU5fHxwPT09NDQpYnJlYWt9
+aWYobz49MClDLk5tLmkoaixvKQplbHNle249Qy5ObS5nclooaikKaWYocCE9PTQ0fHxyIT09bis3fHwh
+Qy54Qi5RaShhLCJiYXNlNjQiLG4rMSkpdGhyb3cgSC5iKFAucnIoIkV4cGVjdGluZyAnPSciLGEscikp
+CmJyZWFrfX1DLk5tLmkoaixyKQptPXIrMQppZigoai5sZW5ndGgmMSk9PT0xKWE9Qy5oOS55cihhLG0s
+cykKZWxzZXtsPVAuVWwoYSxtLHMsQy5WQywhMCkKaWYobCE9bnVsbClhPUMueEIuaTcoYSxtLHMsbCl9
+cmV0dXJuIG5ldyBQLlBFKGEsaixjKX0sCktOOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09IjAx
+MjM0NTY3ODlBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6
+LS5ffiEkJicoKSorLDs9IixsPSIuIixrPSI6IixqPSIvIixpPSI/IixoPSIjIixnPUguVk0obmV3IEFy
+cmF5KDIyKSx0LmdOKQpmb3Iocz0wO3M8MjI7KytzKWdbc109bmV3IFVpbnQ4QXJyYXkoOTYpCnI9bmV3
+IFAueUkoZykKcT1uZXcgUC5jNigpCnA9bmV3IFAucWQoKQpvPXQuZ2MKbj1vLmEoci4kMigwLDIyNSkp
+CnEuJDMobixtLDEpCnEuJDMobixsLDE0KQpxLiQzKG4saywzNCkKcS4kMyhuLGosMykKcS4kMyhuLGks
+MTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTQsMjI1KSkKcS4kMyhuLG0sMSkKcS4kMyhuLGws
+MTUpCnEuJDMobixrLDM0KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpu
+PW8uYShyLiQyKDE1LDIyNSkpCnEuJDMobixtLDEpCnEuJDMobiwiJSIsMjI1KQpxLiQzKG4saywzNCkK
+cS4kMyhuLGosOSkKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMSwyMjUpKQpx
+LiQzKG4sbSwxKQpxLiQzKG4saywzNCkKcS4kMyhuLGosMTApCnEuJDMobixpLDE3MikKcS4kMyhuLGgs
+MjA1KQpuPW8uYShyLiQyKDIsMjM1KSkKcS4kMyhuLG0sMTM5KQpxLiQzKG4saiwxMzEpCnEuJDMobixs
+LDE0NikKcS4kMyhuLGksMTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMywyMzUpKQpxLiQzKG4s
+bSwxMSkKcS4kMyhuLGosNjgpCnEuJDMobixsLDE4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkK
+bj1vLmEoci4kMig0LDIyOSkpCnEuJDMobixtLDUpCnAuJDMobiwiQVoiLDIyOSkKcS4kMyhuLGssMTAy
+KQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4sIlsiLDIzMikKcS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIp
+CnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig1LDIyOSkpCnEuJDMobixtLDUpCnAuJDMobiwiQVoiLDIy
+OSkKcS4kMyhuLGssMTAyKQpxLiQzKG4sIkAiLDY4KQpxLiQzKG4saiwxMzgpCnEuJDMobixpLDE3MikK
+cS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDYsMjMxKSkKcC4kMyhuLCIxOSIsNykKcS4kMyhuLCJAIiw2
+OCkKcS4kMyhuLGosMTM4KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4kMig3LDIz
+MSkpCnAuJDMobiwiMDkiLDcpCnEuJDMobiwiQCIsNjgpCnEuJDMobixqLDEzOCkKcS4kMyhuLGksMTcy
+KQpxLiQzKG4saCwyMDUpCnEuJDMoby5hKHIuJDIoOCw4KSksIl0iLDUpCm49by5hKHIuJDIoOSwyMzUp
+KQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTYpCnEuJDMobixqLDIzNCkKcS4kMyhuLGksMTcyKQpxLiQz
+KG4saCwyMDUpCm49by5hKHIuJDIoMTYsMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixsLDE3KQpxLiQz
+KG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDE3LDIzNSkpCnEu
+JDMobixtLDExKQpxLiQzKG4saiw5KQpxLiQzKG4saSwxNzIpCnEuJDMobixoLDIwNSkKbj1vLmEoci4k
+MigxMCwyMzUpKQpxLiQzKG4sbSwxMSkKcS4kMyhuLGwsMTgpCnEuJDMobixqLDIzNCkKcS4kMyhuLGks
+MTcyKQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTgsMjM1KSkKcS4kMyhuLG0sMTEpCnEuJDMobixs
+LDE5KQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1KQpuPW8uYShyLiQyKDE5
+LDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiwyMzQpCnEuJDMobixpLDE3MikKcS4kMyhuLGgsMjA1
+KQpuPW8uYShyLiQyKDExLDIzNSkpCnEuJDMobixtLDExKQpxLiQzKG4saiwxMCkKcS4kMyhuLGksMTcy
+KQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTIsMjM2KSkKcS4kMyhuLG0sMTIpCnEuJDMobixpLDEy
+KQpxLiQzKG4saCwyMDUpCm49by5hKHIuJDIoMTMsMjM3KSkKcS4kMyhuLG0sMTMpCnEuJDMobixpLDEz
+KQpwLiQzKG8uYShyLiQyKDIwLDI0NSkpLCJheiIsMjEpCnI9by5hKHIuJDIoMjEsMjQ1KSkKcC4kMyhy
+LCJheiIsMjEpCnAuJDMociwiMDkiLDIxKQpxLiQzKHIsIistLiIsMjEpCnJldHVybiBnfSwKVUI6ZnVu
+Y3Rpb24oYSxiLGMsZCxlKXt2YXIgcyxyLHEscCxvLG49JC52WigpCmZvcihzPUouclkoYSkscj1iO3I8
+YzsrK3Ipe2lmKGQ8MHx8ZD49bi5sZW5ndGgpcmV0dXJuIEguT0gobixkKQpxPW5bZF0KcD1zLlcoYSxy
+KV45NgpvPXFbcD45NT8zMTpwXQpkPW8mMzEKQy5ObS5ZNShlLG8+Pj41LHIpfXJldHVybiBkfSwKV0Y6
+ZnVuY3Rpb24gV0YoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCmlQOmZ1bmN0aW9uIGlQKGEsYil7dGhp
+cy5hPWEKdGhpcy5iPWJ9LApYUzpmdW5jdGlvbiBYUygpe30sCkM2OmZ1bmN0aW9uIEM2KGEpe3RoaXMu
+YT1hfSwKRXo6ZnVuY3Rpb24gRXooKXt9LApGOmZ1bmN0aW9uIEYoKXt9LAp1OmZ1bmN0aW9uIHUoYSxi
+LGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZH0sCmJKOmZ1bmN0aW9uIGJKKGEs
+YixjLGQsZSxmKXt2YXIgXz10aGlzCl8uZT1hCl8uZj1iCl8uYT1jCl8uYj1kCl8uYz1lCl8uZD1mfSwK
+ZVk6ZnVuY3Rpb24gZVkoYSxiLGMsZCxlKXt2YXIgXz10aGlzCl8uZj1hCl8uYT1iCl8uYj1jCl8uYz1k
+Cl8uZD1lfSwKbXA6ZnVuY3Rpb24gbXAoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9
+YwpfLmQ9ZH0sCnViOmZ1bmN0aW9uIHViKGEpe3RoaXMuYT1hfSwKZHM6ZnVuY3Rpb24gZHMoYSl7dGhp
+cy5hPWF9LApsajpmdW5jdGlvbiBsaihhKXt0aGlzLmE9YX0sClVWOmZ1bmN0aW9uIFVWKGEpe3RoaXMu
+YT1hfSwKazU6ZnVuY3Rpb24gazUoKXt9LApLWTpmdW5jdGlvbiBLWSgpe30sCmM6ZnVuY3Rpb24gYyhh
+KXt0aGlzLmE9YX0sCkNEOmZ1bmN0aW9uIENEKGEpe3RoaXMuYT1hfSwKYUU6ZnVuY3Rpb24gYUUoYSxi
+LGMpe3RoaXMuYT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKY1g6ZnVuY3Rpb24gY1goKXt9LApBbjpmdW5j
+dGlvbiBBbigpe30sCk4zOmZ1bmN0aW9uIE4zKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLiR0
+aT1jfSwKYzg6ZnVuY3Rpb24gYzgoKXt9LApNaDpmdW5jdGlvbiBNaCgpe30sClpkOmZ1bmN0aW9uIFpk
+KCl7fSwKUm46ZnVuY3Rpb24gUm4oYSl7dGhpcy5hPWF9LApuMTpmdW5jdGlvbiBuMShhKXt0aGlzLmE9
+YX0sCmNTOmZ1bmN0aW9uIGNTKGEpe3RoaXMuYT1hfSwKVkM6ZnVuY3Rpb24gVkMoYSl7dGhpcy5hPWF9
+LApKVDpmdW5jdGlvbiBKVChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKRG46ZnVuY3Rpb24gRG4oYSxi
+LGMsZCxlLGYsZyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZApfLmU9ZQpfLmY9Zgpf
+LnI9ZwpfLng9bnVsbApfLnk9ITEKXy56PW51bGwKXy5RPSExCl8uY2g9bnVsbApfLmN4PSExCl8uY3k9
+bnVsbApfLmRiPSExfSwKUlo6ZnVuY3Rpb24gUlooKXt9LApNRTpmdW5jdGlvbiBNRShhLGIpe3RoaXMu
+YT1hCnRoaXMuYj1ifSwKeTU6ZnVuY3Rpb24geTUoYSl7dGhpcy5hPWF9LApQRTpmdW5jdGlvbiBQRShh
+LGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LAp5STpmdW5jdGlvbiB5SShhKXt0aGlzLmE9
+YX0sCmM2OmZ1bmN0aW9uIGM2KCl7fSwKcWQ6ZnVuY3Rpb24gcWQoKXt9LApVZjpmdW5jdGlvbiBVZihh
+LGIsYyxkLGUsZixnLGgpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy5kPWQKXy5lPWUKXy5m
+PWYKXy5yPWcKXy54PWgKXy55PW51bGx9LApxZTpmdW5jdGlvbiBxZShhLGIsYyxkLGUsZixnKXt2YXIg
+Xz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kCl8uZT1lCl8uZj1mCl8ucj1nCl8ueD1udWxsCl8u
+eT0hMQpfLno9bnVsbApfLlE9ITEKXy5jaD1udWxsCl8uY3g9ITEKXy5jeT1udWxsCl8uZGI9ITF9LApp
+SjpmdW5jdGlvbiBpSigpe30sCmpnOmZ1bmN0aW9uIGpnKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApU
+YTpmdW5jdGlvbiBUYShhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKQmY6ZnVuY3Rpb24gQmYoYSxiKXt0
+aGlzLmE9YQp0aGlzLmI9Yn0sCkFzOmZ1bmN0aW9uIEFzKCl7fSwKR0U6ZnVuY3Rpb24gR0UoYSl7dGhp
+cy5hPWF9LApONzpmdW5jdGlvbiBONyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKdVE6ZnVuY3Rpb24g
+dVEoKXt9LApoRjpmdW5jdGlvbiBoRigpe30sClI0OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQpI
+Lnk4KGIpCnQuai5hKGQpCmlmKEgub1QoYikpe3M9W2NdCkMuTm0uRlYocyxkKQpkPXN9cj10LnoKcT1Q
+LkNIKEouTTEoZCxQLncwKCksciksITAscikKdC5ZLmEoYSkKcmV0dXJuIFAud1koSC5FayhhLHEsbnVs
+bCkpfSwKRG06ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCnRyeXtpZihPYmplY3QuaXNFeHRlbnNpYmxlKGEp
+JiYhT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKGEsYikpe09iamVjdC5kZWZpbmVQ
+cm9wZXJ0eShhLGIse3ZhbHVlOmN9KQpyZXR1cm4hMH19Y2F0Y2gocyl7SC5SdShzKX1yZXR1cm4hMX0s
+Ck9tOmZ1bmN0aW9uKGEsYil7aWYoT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKGEs
+YikpcmV0dXJuIGFbYl0KcmV0dXJuIG51bGx9LAp3WTpmdW5jdGlvbihhKXtpZihhPT1udWxsfHx0eXBl
+b2YgYT09InN0cmluZyJ8fHR5cGVvZiBhPT0ibnVtYmVyInx8SC5sKGEpKXJldHVybiBhCmlmKGEgaW5z
+dGFuY2VvZiBQLkU0KXJldHVybiBhLmEKaWYoSC5SOShhKSlyZXR1cm4gYQppZih0LmFrLmIoYSkpcmV0
+dXJuIGEKaWYoYSBpbnN0YW5jZW9mIFAuaVApcmV0dXJuIEgubzIoYSkKaWYodC5ZLmIoYSkpcmV0dXJu
+IFAuaEUoYSwiJGRhcnRfanNGdW5jdGlvbiIsbmV3IFAuUEMoKSkKcmV0dXJuIFAuaEUoYSwiXyRkYXJ0
+X2pzT2JqZWN0IixuZXcgUC5tdCgkLmtJKCkpKX0sCmhFOmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1QLk9t
+KGEsYikKaWYocz09bnVsbCl7cz1jLiQxKGEpClAuRG0oYSxiLHMpfXJldHVybiBzfSwKZFU6ZnVuY3Rp
+b24oYSl7dmFyIHMscgppZihhPT1udWxsfHx0eXBlb2YgYT09InN0cmluZyJ8fHR5cGVvZiBhPT0ibnVt
+YmVyInx8dHlwZW9mIGE9PSJib29sZWFuIilyZXR1cm4gYQplbHNlIGlmKGEgaW5zdGFuY2VvZiBPYmpl
+Y3QmJkguUjkoYSkpcmV0dXJuIGEKZWxzZSBpZihhIGluc3RhbmNlb2YgT2JqZWN0JiZ0LmFrLmIoYSkp
+cmV0dXJuIGEKZWxzZSBpZihhIGluc3RhbmNlb2YgRGF0ZSl7cz1ILnVQKGEuZ2V0VGltZSgpKQppZihN
+YXRoLmFicyhzKTw9ODY0ZTEzKXI9ITEKZWxzZSByPSEwCmlmKHIpSC52KFAueFkoIkRhdGVUaW1lIGlz
+IG91dHNpZGUgdmFsaWQgcmFuZ2U6ICIrcykpCkguY2IoITEsImlzVXRjIix0LnkpCnJldHVybiBuZXcg
+UC5pUChzLCExKX1lbHNlIGlmKGEuY29uc3RydWN0b3I9PT0kLmtJKCkpcmV0dXJuIGEubwplbHNlIHJl
+dHVybiBQLk5EKGEpfSwKTkQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGE9PSJmdW5jdGlvbiIpcmV0dXJu
+IFAuaVEoYSwkLncoKSxuZXcgUC5RUygpKQppZihhIGluc3RhbmNlb2YgQXJyYXkpcmV0dXJuIFAuaVEo
+YSwkLlI4KCksbmV3IFAubnAoKSkKcmV0dXJuIFAuaVEoYSwkLlI4KCksbmV3IFAuVXQoKSl9LAppUTpm
+dW5jdGlvbihhLGIsYyl7dmFyIHM9UC5PbShhLGIpCmlmKHM9PW51bGx8fCEoYSBpbnN0YW5jZW9mIE9i
+amVjdCkpe3M9Yy4kMShhKQpQLkRtKGEsYixzKX1yZXR1cm4gc30sClBDOmZ1bmN0aW9uIFBDKCl7fSwK
+bXQ6ZnVuY3Rpb24gbXQoYSl7dGhpcy5hPWF9LApRUzpmdW5jdGlvbiBRUygpe30sCm5wOmZ1bmN0aW9u
+IG5wKCl7fSwKVXQ6ZnVuY3Rpb24gVXQoKXt9LApFNDpmdW5jdGlvbiBFNChhKXt0aGlzLmE9YX0sCnI3
+OmZ1bmN0aW9uIHI3KGEpe3RoaXMuYT1hfSwKVHo6ZnVuY3Rpb24gVHooYSxiKXt0aGlzLmE9YQp0aGlz
+LiR0aT1ifSwKY286ZnVuY3Rpb24gY28oKXt9LApuZDpmdW5jdGlvbiBuZCgpe30sCktlOmZ1bmN0aW9u
+IEtlKGEpe3RoaXMuYT1hfSwKaGk6ZnVuY3Rpb24gaGkoKXt9fSxXPXsKeDM6ZnVuY3Rpb24oKXtyZXR1
+cm4gd2luZG93fSwKWnI6ZnVuY3Rpb24oKXtyZXR1cm4gZG9jdW1lbnR9LApKNjpmdW5jdGlvbihhKXt2
+YXIgcz1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCJhIikKaWYoYSE9bnVsbClDLnhuLnNMVShzLGEpCnJl
+dHVybiBzfSwKVTk6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9ZG9jdW1lbnQuYm9keQpyLnRvU3RyaW5n
+CnM9Qy5SWS5yNihyLGEsYixjKQpzLnRvU3RyaW5nCnI9dC5hYwpyPW5ldyBILlU1KG5ldyBXLmU3KHMp
+LHIuQygiYTIobEQuRSkiKS5hKG5ldyBXLkN2KCkpLHIuQygiVTU8bEQuRT4iKSkKcmV0dXJuIHQuaC5h
+KHIuZ3I4KHIpKX0sCnJTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT0iZWxlbWVudCB0YWcgdW5hdmFpbGFi
+bGUiCnRyeXtzPUouWUUoYSkKaWYodHlwZW9mIHMuZ25zKGEpPT0ic3RyaW5nIilxPXMuZ25zKGEpfWNh
+dGNoKHIpe0guUnUocil9cmV0dXJuIHF9LApDMDpmdW5jdGlvbihhLGIpe2E9YStiJjUzNjg3MDkxMQph
+PWErKChhJjUyNDI4Nyk8PDEwKSY1MzY4NzA5MTEKcmV0dXJuIGFeYT4+PjZ9LApyRTpmdW5jdGlvbihh
+LGIsYyxkKXt2YXIgcz1XLkMwKFcuQzAoVy5DMChXLkMwKDAsYSksYiksYyksZCkscj1zKygocyY2NzEw
+ODg2Myk8PDMpJjUzNjg3MDkxMQpyXj1yPj4+MTEKcmV0dXJuIHIrKChyJjE2MzgzKTw8MTUpJjUzNjg3
+MDkxMX0sClROOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWEuY2xhc3NMaXN0CmZvcihzPWIubGVuZ3Ro
+LHI9MDtyPGIubGVuZ3RoO2IubGVuZ3RoPT09c3x8KDAsSC5saykoYiksKytyKXEuYWRkKGJbcl0pfSwK
+SkU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz1XLmFGKG5ldyBXLnZOKGMpLHQuQikKaWYocyE9bnVs
+bCYmITApSi5kWihhLGIscywhMSkKcmV0dXJuIG5ldyBXLnhDKGEsYixzLCExLGUuQygieEM8MD4iKSl9
+LApUdzpmdW5jdGlvbihhKXt2YXIgcz1XLko2KG51bGwpLHI9d2luZG93LmxvY2F0aW9uCnM9bmV3IFcu
+SlEobmV3IFcubWsocyxyKSkKcy5DWShhKQpyZXR1cm4gc30sCnFEOmZ1bmN0aW9uKGEsYixjLGQpe3Qu
+aC5hKGEpCkguaChiKQpILmgoYykKdC5jci5hKGQpCnJldHVybiEwfSwKUVc6ZnVuY3Rpb24oYSxiLGMs
+ZCl7dmFyIHMscixxCnQuaC5hKGEpCkguaChiKQpILmgoYykKcz10LmNyLmEoZCkuYQpyPXMuYQpDLnhu
+LnNMVShyLGMpCnE9ci5ob3N0bmFtZQpzPXMuYgppZighKHE9PXMuaG9zdG5hbWUmJnIucG9ydD09cy5w
+b3J0JiZyLnByb3RvY29sPT1zLnByb3RvY29sKSlpZihxPT09IiIpaWYoci5wb3J0PT09IiIpe3M9ci5w
+cm90b2NvbApzPXM9PT0iOiJ8fHM9PT0iIn1lbHNlIHM9ITEKZWxzZSBzPSExCmVsc2Ugcz0hMApyZXR1
+cm4gc30sCkJsOmZ1bmN0aW9uKCl7dmFyIHM9dC5OLHI9UC50TShDLlF4LHMpLHE9dC5kMC5hKG5ldyBX
+LklBKCkpLHA9SC5WTShbIlRFTVBMQVRFIl0sdC5zKQpzPW5ldyBXLmN0KHIsUC5McyhzKSxQLkxzKHMp
+LFAuTHMocyksbnVsbCkKcy5DWShudWxsLG5ldyBILmxKKEMuUXgscSx0LmZqKSxwLG51bGwpCnJldHVy
+biBzfSwKcWM6ZnVuY3Rpb24oYSl7dmFyIHMKaWYoYT09bnVsbClyZXR1cm4gbnVsbAppZigicG9zdE1l
+c3NhZ2UiIGluIGEpe3M9Vy5QMShhKQppZih0LmFTLmIocykpcmV0dXJuIHMKcmV0dXJuIG51bGx9ZWxz
+ZSByZXR1cm4gdC5jaC5hKGEpfSwKUDE6ZnVuY3Rpb24oYSl7aWYoYT09PXdpbmRvdylyZXR1cm4gdC5j
+aS5hKGEpCmVsc2UgcmV0dXJuIG5ldyBXLmRXKCl9LAphRjpmdW5jdGlvbihhLGIpe3ZhciBzPSQuWDMK
+aWYocz09PUMuTlUpcmV0dXJuIGEKcmV0dXJuIHMuUHkoYSxiKX0sCnFFOmZ1bmN0aW9uIHFFKCl7fSwK
+R2g6ZnVuY3Rpb24gR2goKXt9LApmWTpmdW5jdGlvbiBmWSgpe30sCm5COmZ1bmN0aW9uIG5CKCl7fSwK
+QXo6ZnVuY3Rpb24gQXooKXt9LApRUDpmdW5jdGlvbiBRUCgpe30sCm54OmZ1bmN0aW9uIG54KCl7fSwK
+b0o6ZnVuY3Rpb24gb0ooKXt9LAppZDpmdW5jdGlvbiBpZCgpe30sClFGOmZ1bmN0aW9uIFFGKCl7fSwK
+Tmg6ZnVuY3Rpb24gTmgoKXt9LAphZTpmdW5jdGlvbiBhZSgpe30sCklCOmZ1bmN0aW9uIElCKCl7fSwK
+bjc6ZnVuY3Rpb24gbjcoKXt9LAp3ejpmdW5jdGlvbiB3eihhLGIpe3RoaXMuYT1hCnRoaXMuJHRpPWJ9
+LApjdjpmdW5jdGlvbiBjdigpe30sCkN2OmZ1bmN0aW9uIEN2KCl7fSwKZWE6ZnVuY3Rpb24gZWEoKXt9
+LApEMDpmdW5jdGlvbiBEMCgpe30sCmhIOmZ1bmN0aW9uIGhIKCl7fSwKaDQ6ZnVuY3Rpb24gaDQoKXt9
+LApicjpmdW5jdGlvbiBicigpe30sClZiOmZ1bmN0aW9uIFZiKCl7fSwKZko6ZnVuY3Rpb24gZkooKXt9
+LAp3YTpmdW5jdGlvbiB3YSgpe30sClNnOmZ1bmN0aW9uIFNnKCl7fSwKdzc6ZnVuY3Rpb24gdzcoKXt9
+LApBajpmdW5jdGlvbiBBaigpe30sCmU3OmZ1bmN0aW9uIGU3KGEpe3RoaXMuYT1hfSwKdUg6ZnVuY3Rp
+b24gdUgoKXt9LApCSDpmdW5jdGlvbiBCSCgpe30sClNOOmZ1bmN0aW9uIFNOKCl7fSwKZXc6ZnVuY3Rp
+b24gZXcoKXt9LApscDpmdW5jdGlvbiBscCgpe30sClRiOmZ1bmN0aW9uIFRiKCl7fSwKSXY6ZnVuY3Rp
+b24gSXYoKXt9LApXUDpmdW5jdGlvbiBXUCgpe30sCnlZOmZ1bmN0aW9uIHlZKCl7fSwKdzY6ZnVuY3Rp
+b24gdzYoKXt9LApLNTpmdW5jdGlvbiBLNSgpe30sCkNtOmZ1bmN0aW9uIENtKCl7fSwKQ1E6ZnVuY3Rp
+b24gQ1EoKXt9LAp3NDpmdW5jdGlvbiB3NCgpe30sCnJoOmZ1bmN0aW9uIHJoKCl7fSwKY2Y6ZnVuY3Rp
+b24gY2YoKXt9LAppNzpmdW5jdGlvbiBpNyhhKXt0aGlzLmE9YX0sClN5OmZ1bmN0aW9uIFN5KGEpe3Ro
+aXMuYT1hfSwKS1M6ZnVuY3Rpb24gS1MoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCkEzOmZ1bmN0aW9u
+IEEzKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApJNDpmdW5jdGlvbiBJNChhKXt0aGlzLmE9YX0sCkZr
+OmZ1bmN0aW9uIEZrKGEsYil7dGhpcy5hPWEKdGhpcy4kdGk9Yn0sClJPOmZ1bmN0aW9uIFJPKGEsYixj
+LGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4kdGk9ZH0sCmV1OmZ1bmN0aW9uIGV1KGEs
+YixjLGQpe3ZhciBfPXRoaXMKXy5hPWEKXy5iPWIKXy5jPWMKXy4kdGk9ZH0sCnhDOmZ1bmN0aW9uIHhD
+KGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmI9YQpfLmM9YgpfLmQ9YwpfLmU9ZApfLiR0aT1lfSwKdk46
+ZnVuY3Rpb24gdk4oYSl7dGhpcy5hPWF9LApKUTpmdW5jdGlvbiBKUShhKXt0aGlzLmE9YX0sCkdtOmZ1
+bmN0aW9uIEdtKCl7fSwKdkQ6ZnVuY3Rpb24gdkQoYSl7dGhpcy5hPWF9LApVdjpmdW5jdGlvbiBVdihh
+KXt0aGlzLmE9YX0sCkVnOmZ1bmN0aW9uIEVnKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9
+Y30sCm02OmZ1bmN0aW9uIG02KCl7fSwKRW86ZnVuY3Rpb24gRW8oKXt9LApXazpmdW5jdGlvbiBXaygp
+e30sCmN0OmZ1bmN0aW9uIGN0KGEsYixjLGQsZSl7dmFyIF89dGhpcwpfLmU9YQpfLmE9YgpfLmI9Ywpf
+LmM9ZApfLmQ9ZX0sCklBOmZ1bmN0aW9uIElBKCl7fSwKT3c6ZnVuY3Rpb24gT3coKXt9LApXOTpmdW5j
+dGlvbiBXOShhLGIsYyl7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9LTEKXy5kPW51bGwKXy4kdGk9
+Y30sCmRXOmZ1bmN0aW9uIGRXKCl7fSwKbWs6ZnVuY3Rpb24gbWsoYSxiKXt0aGlzLmE9YQp0aGlzLmI9
+Yn0sCktvOmZ1bmN0aW9uIEtvKGEpe3RoaXMuYT1hCnRoaXMuYj0hMX0sCmZtOmZ1bmN0aW9uIGZtKGEp
+e3RoaXMuYT1hfSwKTGU6ZnVuY3Rpb24gTGUoKXt9LApLNzpmdW5jdGlvbiBLNygpe30sCnJCOmZ1bmN0
+aW9uIHJCKCl7fSwKWFc6ZnVuY3Rpb24gWFcoKXt9LApvYTpmdW5jdGlvbiBvYSgpe319LE09ewpPWDpm
+dW5jdGlvbihhKXtzd2l0Y2goYSl7Y2FzZSBDLkFkOnJldHVybiJBZGQgLyo/Ki8gaGludCIKY2FzZSBD
+Lm5lOnJldHVybiJBZGQgLyohKi8gaGludCIKY2FzZSBDLndWOnJldHVybiJSZW1vdmUgLyo/Ki8gaGlu
+dCIKY2FzZSBDLmZSOnJldHVybiJSZW1vdmUgLyohKi8gaGludCIKY2FzZSBDLm15OnJldHVybiJDaGFu
+Z2UgdG8gLyo/Ki8gaGludCIKY2FzZSBDLnJ4OnJldHVybiJDaGFuZ2UgdG8gLyohKi8gaGludCJ9cmV0
+dXJuIG51bGx9LApINzpmdW5jdGlvbiBINyhhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKWUY6ZnVuY3Rp
+b24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsCmZvcihzPWIubGVuZ3RoLHI9MTtyPHM7KytyKXtpZihi
+W3JdPT1udWxsfHxiW3ItMV0hPW51bGwpY29udGludWUKZm9yKDtzPj0xO3M9cSl7cT1zLTEKaWYoYltx
+XSE9bnVsbClicmVha31wPW5ldyBQLlJuKCIiKQpvPWErIigiCnAuYT1vCm49SC50NihiKQptPW4uQygi
+bkg8MT4iKQpsPW5ldyBILm5IKGIsMCxzLG0pCmwuSGQoYiwwLHMsbi5jKQptPW8rbmV3IEgubEoobCxt
+LkMoInFVKGFMLkUpIikuYShuZXcgTS5ObygpKSxtLkMoImxKPGFMLkUscVU+IikpLmsoMCwiLCAiKQpw
+LmE9bQpwLmE9bSsoIik6IHBhcnQgIisoci0xKSsiIHdhcyBudWxsLCBidXQgcGFydCAiK3IrIiB3YXMg
+bm90LiIpCnRocm93IEguYihQLnhZKHAudygwKSkpfX0sCmxJOmZ1bmN0aW9uIGxJKGEpe3RoaXMuYT1h
+fSwKcTc6ZnVuY3Rpb24gcTcoKXt9LApObzpmdW5jdGlvbiBObygpe319LFU9ewpuejpmdW5jdGlvbihh
+KXt2YXIgcz1ILnVQKGEucSgwLCJub2RlSWQiKSkKcmV0dXJuIG5ldyBVLkxMKEMuTm0uSHQoQy5yayxu
+ZXcgVS5NRChhKSkscyl9LApMTDpmdW5jdGlvbiBMTChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKTUQ6
+ZnVuY3Rpb24gTUQoYSl7dGhpcy5hPWF9LApqZjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscAppZihhPT1u
+dWxsKXM9bnVsbAplbHNle3M9SC5WTShbXSx0LmQ3KQpmb3Iocj1KLklUKHQuVS5hKGEpKTtyLkYoKTsp
+e3E9ci5nbCgpCnA9Si5VNihxKQpzLnB1c2gobmV3IFUuU2UoSC5oKHAucShxLCJkZXNjcmlwdGlvbiIp
+KSxILmgocC5xKHEsImhyZWYiKSkpKX19cmV0dXJuIHN9LApOZDpmdW5jdGlvbihhKXt2YXIgcyxyCmlm
+KGE9PW51bGwpcz1udWxsCmVsc2V7cz1ILlZNKFtdLHQuYUEpCmZvcihyPUouSVQodC5VLmEoYSkpO3Iu
+RigpOylzLnB1c2goVS5OZihyLmdsKCkpKX1yZXR1cm4gc30sCk5mOmZ1bmN0aW9uKGEpe3ZhciBzPUou
+VTYoYSkscj1ILmgocy5xKGEsImRlc2NyaXB0aW9uIikpLHE9SC5WTShbXSx0LmFKKQpmb3Iocz1KLklU
+KHQuVS5hKHMucShhLCJlbnRyaWVzIikpKTtzLkYoKTspcS5wdXNoKFUuUmoocy5nbCgpKSkKcmV0dXJu
+IG5ldyBVLnlEKHIscSl9LApSajpmdW5jdGlvbihhKXt2YXIgcyxyPUouVTYoYSkscT1ILmgoci5xKGEs
+ImRlc2NyaXB0aW9uIikpLHA9SC5oKHIucShhLCJmdW5jdGlvbiIpKSxvPXIucShhLCJsaW5rIikKaWYo
+bz09bnVsbClvPW51bGwKZWxzZXtzPUouVTYobykKbz1uZXcgVS5NbChILmgocy5xKG8sImhyZWYiKSks
+SC51UChzLnEobywibGluZSIpKSxILmgocy5xKG8sInBhdGgiKSkpfXI9dC5mSy5hKHIucShhLCJoaW50
+QWN0aW9ucyIpKQpyPXI9PW51bGw/bnVsbDpKLk0xKHIsbmV3IFUuYU4oKSx0LmFYKQpyPXI9PW51bGw/
+bnVsbDpyLmJyKDApCnJldHVybiBuZXcgVS53YihxLHAsbyxyPT1udWxsP0MuZG46cil9LApkMjpmdW5j
+dGlvbiBkMihhLGIsYyxkLGUsZil7dmFyIF89dGhpcwpfLmE9YQpfLmI9YgpfLmM9YwpfLmQ9ZApfLmU9
+ZQpfLmY9Zn0sClNlOmZ1bmN0aW9uIFNlKGEsYil7dGhpcy5hPWEKdGhpcy5iPWJ9LApNbDpmdW5jdGlv
+biBNbChhLGIsYyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LAp5RDpmdW5jdGlvbiB5RChhLGIp
+e3RoaXMuYT1hCnRoaXMuYj1ifSwKd2I6ZnVuY3Rpb24gd2IoYSxiLGMsZCl7dmFyIF89dGhpcwpfLmE9
+YQpfLmI9YgpfLmM9YwpfLmQ9ZH0sCmFOOmZ1bmN0aW9uIGFOKCl7fSwKYjA6ZnVuY3Rpb24gYjAoKXt9
+fSxCPXsKd1I6ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEIucXAoIiIsIiIsIiIsQy5EeCl9LApZZjpmdW5j
+dGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9SC5oKGEucSgwLCJyZWdpb25zIikpLGo9SC5oKGEu
+cSgwLCJuYXZpZ2F0aW9uQ29udGVudCIpKSxpPUguaChhLnEoMCwic291cmNlQ29kZSIpKSxoPVAuRmwo
+dC5YLHQuZF8pCmZvcihzPXQudC5hKGEucSgwLCJlZGl0cyIpKSxzPXMuZ1B1KHMpLHM9cy5nbShzKSxy
+PXQuVSxxPXQuaDQ7cy5GKCk7KXtwPXMuZ2woKQpvPXAuYQpuPUguVk0oW10scSkKZm9yKHA9Si5JVChy
+LmEocC5iKSk7cC5GKCk7KXttPXAuZ2woKQpsPUouVTYobSkKbi5wdXNoKG5ldyBCLmo4KEgudVAobC5x
+KG0sImxpbmUiKSksSC5oKGwucShtLCJleHBsYW5hdGlvbiIpKSxILnVQKGwucShtLCJvZmZzZXQiKSkp
+KX1oLlk1KDAsbyxuKX1yZXR1cm4gbmV3IEIucXAoayxqLGksaCl9LApqODpmdW5jdGlvbiBqOChhLGIs
+Yyl7dGhpcy5hPWEKdGhpcy5iPWIKdGhpcy5jPWN9LApxcDpmdW5jdGlvbiBxcChhLGIsYyxkKXt2YXIg
+Xz10aGlzCl8uYT1hCl8uYj1iCl8uYz1jCl8uZD1kfSwKZnY6ZnVuY3Rpb24gZnYoKXt9LApPUzpmdW5j
+dGlvbihhKXt2YXIgcwppZighKGE+PTY1JiZhPD05MCkpcz1hPj05NyYmYTw9MTIyCmVsc2Ugcz0hMApy
+ZXR1cm4gc30sCll1OmZ1bmN0aW9uKGEsYil7dmFyIHM9YS5sZW5ndGgscj1iKzIKaWYoczxyKXJldHVy
+biExCmlmKCFCLk9TKEMueEIuTzIoYSxiKSkpcmV0dXJuITEKaWYoQy54Qi5PMihhLGIrMSkhPT01OCly
+ZXR1cm4hMQppZihzPT09cilyZXR1cm4hMApyZXR1cm4gQy54Qi5PMihhLHIpPT09NDd9fSxUPXttUTpm
+dW5jdGlvbiBtUSgpe319LEw9ewpJcTpmdW5jdGlvbigpe0MuQlouQihkb2N1bWVudCwiRE9NQ29udGVu
+dExvYWRlZCIsbmV3IEwuZSgpKQpDLm9sLkIod2luZG93LCJwb3BzdGF0ZSIsbmV3IEwuTCgpKX0sCmt6
+OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dC5nLmEoYS5wYXJlbnROb2RlKS5xdWVyeVNlbGVjdG9yKCI6c2Nv
+cGUgPiB1bCIpLHE9ci5zdHlsZSxwPSIiK0MuQ0QuelEoci5vZmZzZXRIZWlnaHQpKjIrInB4IgpxLm1h
+eEhlaWdodD1wCnE9Si5xRihhKQpwPXEuJHRpCnM9cC5DKCJ+KDEpPyIpLmEobmV3IEwuV3gocixhKSkK
+dC5aLmEobnVsbCkKVy5KRShxLmEscS5iLHMsITEscC5jKX0sCnlYOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxLHAsbyxuLG09InF1ZXJ5U2VsZWN0b3JBbGwiLGw9ZG9jdW1lbnQucXVlcnlTZWxlY3RvcihhKSxr
+PXQuZwpsLnRvU3RyaW5nCnM9dC5oCkguRGgoayxzLCJUIixtKQpyPXQuUgpxPW5ldyBXLnd6KGwucXVl
+cnlTZWxlY3RvckFsbCgiLm5hdi1saW5rIikscikKcS5LKHEsbmV3IEwuQU8oYikpCkguRGgoayxzLCJU
+IixtKQpwPW5ldyBXLnd6KGwucXVlcnlTZWxlY3RvckFsbCgiLnJlZ2lvbiIpLHIpCmlmKCFwLmdsMChw
+KSl7bz1sLnF1ZXJ5U2VsZWN0b3IoInRhYmxlW2RhdGEtcGF0aF0iKQpvLnRvU3RyaW5nCnAuSyhwLG5l
+dyBMLkhvKG8uZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcobykpLlAoInBhdGgi
+KSkpKX1ILkRoKGsscywiVCIsbSkKbj1uZXcgVy53eihsLnF1ZXJ5U2VsZWN0b3JBbGwoIi5hZGQtaGlu
+dC1saW5rIikscikKbi5LKG4sbmV3IEwuSUMoKSl9LApRNjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9bmV3
+IFhNTEh0dHBSZXF1ZXN0KCkKQy5EdC5lbyhzLCJHRVQiLEwuUTQoYSxiKSwhMCkKcy5zZXRSZXF1ZXN0
+SGVhZGVyKCJDb250ZW50LVR5cGUiLCJhcHBsaWNhdGlvbi9qc29uOyBjaGFyc2V0PVVURi04IikKcmV0
+dXJuIEwuTFUocyxudWxsLGMuQygiMCoiKSl9LAp0eTpmdW5jdGlvbihhLGIpe3ZhciBzPW5ldyBYTUxI
+dHRwUmVxdWVzdCgpLHI9dC5YCkMuRHQuZW8ocywiUE9TVCIsTC5RNChhLFAuRmwocixyKSksITApCnMu
+c2V0UmVxdWVzdEhlYWRlcigiQ29udGVudC1UeXBlIiwiYXBwbGljYXRpb24vanNvbjsgY2hhcnNldD1V
+VEYtOCIpCnJldHVybiBMLkxVKHMsYix0LnQpfSwKTFU6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBMLlRn
+KGEsYixjLGMuQygiMCoiKSl9LApUZzpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcz0wLHI9UC5GWChkKSxx
+LHA9MixvLG49W10sbSxsLGssaixpLGgsZyxmCnZhciAkYXN5bmMkTFU9UC5seihmdW5jdGlvbihlLGEw
+KXtpZihlPT09MSl7bz1hMApzPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOmk9bmV3IFAuWmYo
+bmV3IFAudnMoJC5YMyx0LmdWKSx0LmJDKQpoPXQuZWIKZz1oLmEobmV3IEwuZkMoaSxhKSkKdC5aLmEo
+bnVsbCkKbD10LmVRClcuSkUoYSwibG9hZCIsZywhMSxsKQpXLkpFKGEsImVycm9yIixoLmEoaS5nWUoo
+KSksITEsbCkKYS5zZW5kKGI9PW51bGw/bnVsbDpDLkN0Lk9CKGIsbnVsbCkpCnA9NApzPTcKcmV0dXJu
+IFAualEoaS5hLCRhc3luYyRMVSkKY2FzZSA3OnA9MgpzPTYKYnJlYWsKY2FzZSA0OnA9MwpmPW8KSC5S
+dShmKQptPUgudHMoZikKaD1QLlRsKCJFcnJvciByZWFjaGluZyBtaWdyYXRpb24gcHJldmlldyBzZXJ2
+ZXIuIixtKQp0aHJvdyBILmIoaCkKcz02CmJyZWFrCmNhc2UgMzpzPTIKYnJlYWsKY2FzZSA2Omo9Qy5D
+dC5wVygwLGEucmVzcG9uc2VUZXh0LG51bGwpCmlmKGEuc3RhdHVzPT09MjAwKXtxPWMuQygiMCoiKS5h
+KGopCnM9MQpicmVha31lbHNlIHRocm93IEguYihqKQpjYXNlIDE6cmV0dXJuIFAueUMocSxyKQpjYXNl
+IDI6cmV0dXJuIFAuZjMobyxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkTFUscil9LAphSzpmdW5jdGlv
+bihhKXt2YXIgcz1QLmhLKGEpLmdoWSgpLnEoMCwibGluZSIpCnJldHVybiBzPT1udWxsP251bGw6SC5I
+cChzLG51bGwpfSwKRzY6ZnVuY3Rpb24oYSl7dmFyIHM9UC5oSyhhKS5naFkoKS5xKDAsIm9mZnNldCIp
+CnJldHVybiBzPT1udWxsP251bGw6SC5IcChzLG51bGwpfSwKaTY6ZnVuY3Rpb24oYSl7cmV0dXJuIEwu
+blcodC5PLmEoYSkpfSwKblc6ZnVuY3Rpb24oYSl7dmFyIHM9MCxyPVAuRlgodC56KSxxPTEscCxvPVtd
+LG4sbSxsLGssaixpLGgKdmFyICRhc3luYyRpNj1QLmx6KGZ1bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9
+YwpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOmk9dC5nLmEoVy5xYyhhLmN1cnJlbnRUYXJn
+ZXQpKS5nZXRBdHRyaWJ1dGUoImhyZWYiKQphLnByZXZlbnREZWZhdWx0KCkKcT0zCms9ZG9jdW1lbnQK
+bj1DLkNELnpRKGsucXVlcnlTZWxlY3RvcigiLmNvbnRlbnQiKS5zY3JvbGxUb3ApCnM9NgpyZXR1cm4g
+UC5qUShMLnR5KGksbnVsbCksJGFzeW5jJGk2KQpjYXNlIDY6cz03CnJldHVybiBQLmpRKEwuRzcod2lu
+ZG93LmxvY2F0aW9uLnBhdGhuYW1lLG51bGwsbnVsbCwhMSxudWxsKSwkYXN5bmMkaTYpCmNhc2UgNzpr
+PWsucXVlcnlTZWxlY3RvcigiLmNvbnRlbnQiKQprLnRvU3RyaW5nCmsuc2Nyb2xsVG9wPUouVnUobikK
+cT0xCnM9NQpicmVhawpjYXNlIDM6cT0yCmg9cAptPUguUnUoaCkKbD1ILnRzKGgpCkwuQzIoIkNvdWxk
+IG5vdCBhZGQvcmVtb3ZlIGhpbnQiLG0sbCkKcz01CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1
+OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREko
+JGFzeW5jJGk2LHIpfSwKQzI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwPSJleGNlcHRpb24iLG89
+InN0YWNrVHJhY2UiLG49dC50LmIoYikmJkouUk0oYi5xKDAsInN1Y2Nlc3MiKSwhMSkmJmIueDQocCkm
+JmIueDQobyksbT1KLmlhKGIpCmlmKG4pe3M9SC5oKG0ucShiLHApKQpjPW0ucShiLG8pfWVsc2Ugcz1t
+LncoYikKbj1kb2N1bWVudApyPW4ucXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKQpyLnF1ZXJ5U2Vs
+ZWN0b3IoImgyIikuaW5uZXJUZXh0PWEKci5xdWVyeVNlbGVjdG9yKCJwIikuaW5uZXJUZXh0PXMKci5x
+dWVyeVNlbGVjdG9yKCJwcmUiKS5pbm5lclRleHQ9Si5qKGMpCnE9dC5kZC5hKHIucXVlcnlTZWxlY3Rv
+cigiYS5ib3R0b20iKSkKbT10Llg7KHEmJkMueG4pLnNMVShxLFAuWGQoImh0dHBzIiwiZ2l0aHViLmNv
+bSIsImRhcnQtbGFuZy9zZGsvaXNzdWVzL25ldyIsUC5FRihbInRpdGxlIiwiQ3VzdG9tZXItcmVwb3J0
+ZWQgaXNzdWUgd2l0aCBOTkJEIG1pZ3JhdGlvbiB0b29sOiAiK2EsImxhYmVscyIsdS5kLCJib2R5Iixh
+KyJcblxuRXJyb3I6ICIrSC5FaihzKSsiXG5cblBsZWFzZSBmaWxsIGluIHRoZSBmb2xsb3dpbmc6XG5c
+bioqTmFtZSBvZiBwYWNrYWdlIGJlaW5nIG1pZ3JhdGVkIChpZiBwdWJsaWMpKio6XG4qKldoYXQgSSB3
+YXMgZG9pbmcgd2hlbiB0aGlzIGlzc3VlIG9jY3VycmVkKio6XG4qKklzIGl0IHBvc3NpYmxlIHRvIHdv
+cmsgYXJvdW5kIHRoaXMgaXNzdWUqKjpcbioqSGFzIHRoaXMgaXNzdWUgaGFwcGVuZWQgYmVmb3JlLCBh
+bmQgaWYgc28sIGhvdyBvZnRlbioqOlxuKipEYXJ0IFNESyB2ZXJzaW9uKio6ICIrSC5FaihuLmdldEVs
+ZW1lbnRCeUlkKCJzZGstdmVyc2lvbiIpLnRleHRDb250ZW50KSsiXG4qKkFkZGl0aW9uYWwgZGV0YWls
+cyoqOlxuXG5UaGFua3MgZm9yIGZpbGluZyFcblxuU3RhY2t0cmFjZTogX2F1dG8gcG9wdWxhdGVkIGJ5
+IG1pZ3JhdGlvbiBwcmV2aWV3IHRvb2wuX1xuXG5gYGBcbiIrSC5FaihjKSsiXG5gYGBcbiJdLG0sbSkp
+LmduRCgpKQptPXEuc3R5bGUKbS5kaXNwbGF5PSJpbml0aWFsIgpuPXIuc3R5bGUKbi5kaXNwbGF5PSJp
+bml0aWFsIgpuPWErIjogIitILkVqKGIpCndpbmRvdwppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5l
+ZCIpd2luZG93LmNvbnNvbGUuZXJyb3IobikKd2luZG93Cm49SC5FaihjKQppZih0eXBlb2YgY29uc29s
+ZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUuZXJyb3Iobil9LAp0MjpmdW5jdGlvbihhLGIsYyl7
+dmFyIHMscixxLHAsbz10LmcuYShXLnFjKGEuY3VycmVudFRhcmdldCkpCmEucHJldmVudERlZmF1bHQo
+KQpzPW8uZ2V0QXR0cmlidXRlKCJocmVmIikKcj1MLlVzKHMpCnE9TC5HNihzKQpwPUwuYUsocykKaWYo
+cSE9bnVsbClMLmFmKHIscSxwLGIsbmV3IEwublQocixxLHApKQplbHNlIEwuYWYocixudWxsLG51bGws
+YixuZXcgTC5OWShyKSl9LApLMDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1kb2N1bWVudC5xdWVyeVNl
+bGVjdG9yKCIucG9wdXAtcGFuZSIpCnAucXVlcnlTZWxlY3RvcigiaDIiKS5pbm5lclRleHQ9IkZhaWxl
+ZCB0byByZXJ1biBmcm9tIHNvdXJjZXMiCnAucXVlcnlTZWxlY3RvcigicCIpLmlubmVyVGV4dD0iU291
+cmNlcyBjb250YWluIHN0YXRpYyBhbmFseXNpcyBlcnJvcnM6IgpzPXAucXVlcnlTZWxlY3RvcigicHJl
+IikKcj1KLkVsKGEsdC5hdykKcT1ILkxoKHIpCnMuaW5uZXJUZXh0PW5ldyBILmxKKHIscS5DKCJxVSoo
+bEQuRSkiKS5hKG5ldyBMLnVlKCkpLHEuQygibEo8bEQuRSxxVSo+IikpLmsoMCwiXG4iKQpxPXAucXVl
+cnlTZWxlY3RvcigiYS5ib3R0b20iKS5zdHlsZQpxLmRpc3BsYXk9Im5vbmUiCnM9cC5zdHlsZQpzLmRp
+c3BsYXk9ImluaXRpYWwifSwKdlU6ZnVuY3Rpb24oKXt2YXIgcz1kb2N1bWVudApILkRoKHQuZyx0Lmgs
+IlQiLCJxdWVyeVNlbGVjdG9yQWxsIikKcz1uZXcgVy53eihzLnF1ZXJ5U2VsZWN0b3JBbGwoIi5jb2Rl
+IiksdC5SKQpzLksocyxuZXcgTC5lWCgpKX0sCmhYOmZ1bmN0aW9uKGEsYixjKXtyZXR1cm4gTC5Zdyhh
+LGIsYyl9LApZdzpmdW5jdGlvbihhLGIsYyl7dmFyIHM9MCxyPVAuRlgodC56KSxxPTEscCxvPVtdLG4s
+bSxsLGssaixpLGgsZwp2YXIgJGFzeW5jJGhYPVAubHooZnVuY3Rpb24oZCxlKXtpZihkPT09MSl7cD1l
+CnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6cT0zCmo9dC5YCnM9NgpyZXR1cm4gUC5qUShM
+LlE2KGEsUC5FRihbInJlZ2lvbiIsInJlZ2lvbiIsIm9mZnNldCIsSC5FaihiKV0saixqKSx0LnQpLCRh
+c3luYyRoWCkKY2FzZSA2Om49ZQpqPW4KaT1KLlU2KGopCm09bmV3IFUuZDIoVS5qZihpLnEoaiwiZWRp
+dHMiKSksSC5oKGkucShqLCJleHBsYW5hdGlvbiIpKSxILnVQKGkucShqLCJsaW5lIikpLEguaChpLnEo
+aiwiZGlzcGxheVBhdGgiKSksSC5oKGkucShqLCJ1cmlQYXRoIikpLFUuTmQoaS5xKGosInRyYWNlcyIp
+KSkKTC5UMShtKQpMLkZyKGEsYixjKQpMLnlYKCIuZWRpdC1wYW5lbCAucGFuZWwtY29udGVudCIsITEp
+CnE9MQpzPTUKYnJlYWsKY2FzZSAzOnE9MgpnPXAKbD1ILlJ1KGcpCms9SC50cyhnKQpMLkMyKCJDb3Vs
+ZCBub3QgbG9hZCBlZGl0IGRldGFpbHMiLGwsaykKcz01CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2Fz
+ZSA1OnJldHVybiBQLnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAu
+REkoJGFzeW5jJGhYLHIpfSwKRzc6ZnVuY3Rpb24oYSxiLGMsZCxlKXtyZXR1cm4gTC5MNShhLGIsYyxk
+LGUpfSwKTDU6ZnVuY3Rpb24oYSxiLGMsZCxlKXt2YXIgcz0wLHI9UC5GWCh0LkgpLHEscD0yLG8sbj1b
+XSxtLGwsayxqLGksaCxnCnZhciAkYXN5bmMkRzc9UC5seihmdW5jdGlvbihmLGEwKXtpZihmPT09MSl7
+bz1hMApzPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2FzZSAwOmlmKCFKLnA0KGEsIi5kYXJ0Iikpe0wu
+QkUoYSxCLndSKCksZCkKTC5CWChhLG51bGwpCmlmKGUhPW51bGwpZS4kMCgpCnM9MQpicmVha31wPTQK
+aT10LlgKcz03CnJldHVybiBQLmpRKEwuUTYoYSxQLkVGKFsiaW5saW5lIiwidHJ1ZSJdLGksaSksdC50
+KSwkYXN5bmMkRzcpCmNhc2UgNzptPWEwCkwuQkUoYSxCLllmKG0pLGQpCkwuZkcoYixjKQpsPUwuVXMo
+YSkKTC5CWChsLGIpCmlmKGUhPW51bGwpZS4kMCgpCnA9MgpzPTYKYnJlYWsKY2FzZSA0OnA9MwpnPW8K
+az1ILlJ1KGcpCmo9SC50cyhnKQpMLkMyKCJDb3VsZCBub3QgbG9hZCBkYXJ0IGZpbGUgIithLGssaikK
+cz02CmJyZWFrCmNhc2UgMzpzPTIKYnJlYWsKY2FzZSA2OmNhc2UgMTpyZXR1cm4gUC55QyhxLHIpCmNh
+c2UgMjpyZXR1cm4gUC5mMyhvLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyRHNyxyKX0sCkdlOmZ1bmN0
+aW9uKCl7dmFyIHM9MCxyPVAuRlgodC56KSxxPTEscCxvPVtdLG4sbSxsLGssaixpLGgsZwp2YXIgJGFz
+eW5jJEdlPVAubHooZnVuY3Rpb24oYSxiKXtpZihhPT09MSl7cD1iCnM9cX13aGlsZSh0cnVlKXN3aXRj
+aChzKXtjYXNlIDA6aD0iL19wcmV2aWV3L25hdmlnYXRpb25UcmVlLmpzb24iCnE9MwpzPTYKcmV0dXJu
+IFAualEoTC5RNihoLEMuQ00sdC5lRSksJGFzeW5jJEdlKQpjYXNlIDY6bj1iCm09ZG9jdW1lbnQucXVl
+cnlTZWxlY3RvcigiLm5hdi10cmVlIikKSi5sNShtLCIiKQpqPUwubUsobikKJC5JUj1qCkwudFgobSxq
+LCExKQpxPTEKcz01CmJyZWFrCmNhc2UgMzpxPTIKZz1wCmw9SC5SdShnKQprPUgudHMoZykKTC5DMigi
+Q291bGQgbm90IGxvYWQgbmF2aWdhdGlvbiB0cmVlIixsLGspCnM9NQpicmVhawpjYXNlIDI6cz0xCmJy
+ZWFrCmNhc2UgNTpyZXR1cm4gUC55QyhudWxsLHIpCmNhc2UgMTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJl
+dHVybiBQLkRJKCRhc3luYyRHZSxyKX0sCnFPOmZ1bmN0aW9uKGEpe3ZhciBzLHI9YS5nZXRCb3VuZGlu
+Z0NsaWVudFJlY3QoKSxxPUMuQ0QuelEoJC5maSgpLm9mZnNldEhlaWdodCkscD13aW5kb3cuaW5uZXJI
+ZWlnaHQsbz1DLkNELnpRKCQuRFcoKS5vZmZzZXRIZWlnaHQpCmlmKHR5cGVvZiBwIT09Im51bWJlciIp
+cmV0dXJuIHAuSE4oKQpzPXIuYm90dG9tCnMudG9TdHJpbmcKaWYocz5wLShvKzE0KSlKLmRoKGEpCmVs
+c2V7cD1yLnRvcApwLnRvU3RyaW5nCmlmKHA8cSsxNClKLmRoKGEpfX0sCmZHOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxLHAsbwppZihhIT1udWxsKXtzPWRvY3VtZW50CnI9cy5nZXRFbGVtZW50QnlJZCgibyIr
+SC5FaihhKSkKcT1zLnF1ZXJ5U2VsZWN0b3IoIi5saW5lLSIrSC5FaihiKSkKaWYociE9bnVsbCl7TC5x
+TyhyKQpKLmRSKHIpLmkoMCwidGFyZ2V0Iil9ZWxzZSBpZihxIT1udWxsKUwucU8ocS5wYXJlbnRFbGVt
+ZW50KQppZihxIT1udWxsKUouZFIodC5nLmEocS5wYXJlbnROb2RlKSkuaSgwLCJoaWdobGlnaHQiKX1l
+bHNle3M9ZG9jdW1lbnQKcD10LmcKSC5EaChwLHQuaCwiVCIsInF1ZXJ5U2VsZWN0b3JBbGwiKQpzPXMu
+cXVlcnlTZWxlY3RvckFsbCgiLmxpbmUtbm8iKQpvPW5ldyBXLnd6KHMsdC5SKQppZihvLmdBKG8pPT09
+MClyZXR1cm4KTC5xTyhwLmEoQy50NS5ndEgocykpKX19LAphZjpmdW5jdGlvbihhLGIsYyxkLGUpe3Zh
+ciBzLHIscT1MLkc2KHdpbmRvdy5sb2NhdGlvbi5ocmVmKSxwPUwuYUsod2luZG93LmxvY2F0aW9uLmhy
+ZWYpCmlmKHEhPW51bGwpe3M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm8iK0guRWoocSkpCmlmKHMh
+PW51bGwpSi5kUihzKS5MKDAsInRhcmdldCIpfWlmKHAhPW51bGwpe3I9ZG9jdW1lbnQucXVlcnlTZWxl
+Y3RvcigiLmxpbmUtIitILkVqKHApKQppZihyIT1udWxsKUouZFIoci5wYXJlbnRFbGVtZW50KS5MKDAs
+ImhpZ2hsaWdodCIpfWlmKGE9PXdpbmRvdy5sb2NhdGlvbi5wYXRobmFtZSl7TC5mRyhiLGMpCmUuJDAo
+KX1lbHNlIEwuRzcoYSxiLGMsZCxlKX0sClE0OmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPVAuaEsoYSks
+cD10LlgKcD1QLkZsKHAscCkKZm9yKHM9cS5naFkoKSxzPXMuZ1B1KHMpLHM9cy5nbShzKTtzLkYoKTsp
+e3I9cy5nbCgpCnAuWTUoMCxyLmEsci5iKX1mb3Iocz1iLmdQdShiKSxzPXMuZ20ocyk7cy5GKCk7KXty
+PXMuZ2woKQpwLlk1KDAsci5hLHIuYil9cC5ZNSgwLCJhdXRoVG9rZW4iLCQuVUUoKSkKcmV0dXJuIHEu
+bm0oMCxwKS5nbkQoKX0sClQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqPSQuaEwo
+KQpKLmw1KGosIiIpCmlmKGE9PW51bGwpe3M9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgicCIpCkMuTHQu
+c2E0KHMsIlNlZSBkZXRhaWxzIGFib3V0IGEgcHJvcG9zZWQgZWRpdC4iKQpDLkx0LnNuKHMsSC5WTShb
+InBsYWNlaG9sZGVyIl0sdC5pKSkKai5hcHBlbmRDaGlsZChzKQpDLkx0LkZGKHMpCnJldHVybn1yPWEu
+ZApxPSQublUoKQpwPXEuemYocikKbz1hLmIKbj1kb2N1bWVudAptPXEuSFAocixKLlQwKG4ucXVlcnlT
+ZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29udGVudCkpCmw9YS5jCms9bi5jcmVhdGVFbGVtZW50KCJwIikK
+ai5hcHBlbmRDaGlsZChrKQprLmFwcGVuZENoaWxkKG4uY3JlYXRlVGV4dE5vZGUoSC5FaihvKSsiIGF0
+ICIpKQpxPXQuWApxPVcuSjYoTC5RNChhLmUsUC5FRihbImxpbmUiLEouaihsKV0scSxxKSkpCnEuYXBw
+ZW5kQ2hpbGQobi5jcmVhdGVUZXh0Tm9kZShILkVqKG0pKyI6IitILkVqKGwpKyIuIikpCmsuYXBwZW5k
+Q2hpbGQocSkKSi5kaChrKQpMLkNDKGEsaixwKQpMLkZ6KGEsail9LApMSDpmdW5jdGlvbihhLGIsYyl7
+dmFyIHMscixxLHAsbyxuLG0sbCxrLGosaSxoLGcsZixlPSQueVAoKQpKLmw1KGUsIiIpCmlmKGIuZ0Eo
+Yik9PT0wKXtzPWRvY3VtZW50CnI9cy5jcmVhdGVFbGVtZW50KCJwIikKZS5hcHBlbmRDaGlsZChyKQpy
+LmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUoIk5vIHByb3Bvc2VkIGVkaXRzIikpfWVsc2UgZm9y
+KGU9Yi5nUHUoYiksZT1lLmdtKGUpLHM9dC5YLHE9dC5rLHA9cS5DKCJ+KDEpPyIpLG89dC5aLHE9cS5j
+O2UuRigpOyl7bj1lLmdsKCkKbT1kb2N1bWVudApyPW0uY3JlYXRlRWxlbWVudCgicCIpCmw9JC55UCgp
+CmwuYXBwZW5kQ2hpbGQocikKci5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKEguRWoobi5hKSsi
+OiIpKQprPW0uY3JlYXRlRWxlbWVudCgidWwiKQpsLmFwcGVuZENoaWxkKGspCmZvcihuPUouSVQobi5i
+KTtuLkYoKTspe2w9bi5nbCgpCmo9bS5jcmVhdGVFbGVtZW50KCJsaSIpCmsuYXBwZW5kQ2hpbGQoaikK
+Si5kUihqKS5pKDAsImVkaXQiKQppPW0uY3JlYXRlRWxlbWVudCgiYSIpCmouYXBwZW5kQ2hpbGQoaSkK
+aS5jbGFzc0xpc3QuYWRkKCJlZGl0LWxpbmsiKQpoPWwuYwpnPUguRWooaCkKaS5zZXRBdHRyaWJ1dGUo
+ImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhpKSkuUCgib2Zmc2V0IiksZykKZj1sLmEKZz1ILkVqKGYp
+Cmkuc2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcoaSkpLlAoImxpbmUiKSxnKQpp
+LmFwcGVuZENoaWxkKG0uY3JlYXRlVGV4dE5vZGUoImxpbmUgIitILkVqKGYpKSkKaS5zZXRBdHRyaWJ1
+dGUoImhyZWYiLEwuUTQod2luZG93LmxvY2F0aW9uLnBhdGhuYW1lLFAuRUYoWyJsaW5lIixILkVqKGYp
+LCJvZmZzZXQiLEguRWooaCldLHMscykpKQpnPXAuYShuZXcgTC5FRShoLGYsYSkpCm8uYShudWxsKQpX
+LkpFKGksImNsaWNrIixnLCExLHEpCmouYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiOiAiK0gu
+RWoobC5iKSkpfX1pZihjKUwuVDEobnVsbCl9LApGcjpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxPXdp
+bmRvdy5sb2NhdGlvbixwPVAuaEsoKHEmJkMuRXgpLmdEcihxKStILkVqKGEpKQpxPXQuWApxPVAuRmwo
+cSxxKQppZihiIT1udWxsKXEuWTUoMCwib2Zmc2V0IixILkVqKGIpKQppZihjIT1udWxsKXEuWTUoMCwi
+bGluZSIsSC5FaihjKSkKcS5ZNSgwLCJhdXRoVG9rZW4iLCQuVUUoKSkKcD1wLm5tKDAscSkKcT13aW5k
+b3cuaGlzdG9yeQpzPXQuegpyPXAuZ25EKCkKcS50b1N0cmluZwpxLnB1c2hTdGF0ZShuZXcgUC5CZihb
+XSxbXSkuUHYoUC5GbChzLHMpKSwiIixyKX0sCkVuOmZ1bmN0aW9uKGEpe3ZhciBzPUouYmIoZG9jdW1l
+bnQucXVlcnlTZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29udGVudCwiLyIpCmlmKEMueEIubkMoYSxzKSly
+ZXR1cm4gQy54Qi55bihhLHMubGVuZ3RoKQplbHNlIHJldHVybiBhfSwKT3Q6ZnVuY3Rpb24oYSl7c3dp
+dGNoKGEucil7Y2FzZSBDLmN3OmJyZWFrCmNhc2UgQy5XRDphLnI9Qy5YagpicmVhawpjYXNlIEMuWGo6
+YS5yPUMuV0QKYnJlYWsKY2FzZSBDLmRjOnRocm93IEguYihQLlBWKCJGaWxlICIrSC5FaihhLmMpKyIg
+c2hvdWxkIG5vdCBoYXZlIGluZGV0ZXJtaW5hdGUgbWlncmF0aW9uIHN0YXR1cyIpKX19LAp4bjpmdW5j
+dGlvbihhLGIpe0wudGEoYSxiLmdkNigpKQppZihiLmM9PSQuRDkoKS5pbm5lclRleHQpTC50YSgkLmMw
+KCksYi5nZDYoKSl9LAp0YTpmdW5jdGlvbihhLGIpe3ZhciBzLHI9ImNoZWNrX2JveCIscT0idGl0bGUi
+LHA9Im9wdGVkLW91dCIsbz0ibWlncmF0aW5nIgpzd2l0Y2goYil7Y2FzZSBDLmN3OmEuaW5uZXJUZXh0
+PXIKSi5kUihhKS5pKDAsImFscmVhZHktbWlncmF0ZWQiKQphLnNldEF0dHJpYnV0ZShxLCJBbHJlYWR5
+IG1pZ3JhdGVkIikKYnJlYWsKY2FzZSBDLldEOmEuaW5uZXJUZXh0PXIKcz1KLllFKGEpCnMuZ24oYSku
+TCgwLHApCnMuZ24oYSkuaSgwLG8pCmEuc2V0QXR0cmlidXRlKHEsIk1pZ3JhdGluZyB0byBudWxsIHNh
+ZmV0eSIpCmJyZWFrCmNhc2UgQy5YajphLmlubmVyVGV4dD0iY2hlY2tfYm94X291dGxpbmVfYmxhbmsi
+CnM9Si5ZRShhKQpzLmduKGEpLkwoMCxvKQpzLmduKGEpLmkoMCxwKQphLnNldEF0dHJpYnV0ZShxLCJP
+cHRpbmcgb3V0IG9mIG51bGwgc2FmZXR5IikKYnJlYWsKZGVmYXVsdDphLmlubmVyVGV4dD0iaW5kZXRl
+cm1pbmF0ZV9jaGVja19ib3giCnM9Si5ZRShhKQpzLmduKGEpLkwoMCxvKQpzLmduKGEpLmkoMCxwKQph
+LnNldEF0dHJpYnV0ZShxLCJNaXhlZCBzdGF0dXNlcyBvZiAnbWlncmF0aW5nJyBhbmQgJ29wdGluZyBv
+dXQnIikKYnJlYWt9fSwKQlg6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXt9CnIuYT1hCmE9TC5FbihhKQpy
+LmE9YQpKLmRyKCQuRDkoKSxhKQpzPWRvY3VtZW50CkguRGgodC5nLHQuaCwiVCIsInF1ZXJ5U2VsZWN0
+b3JBbGwiKQpzPW5ldyBXLnd6KHMucXVlcnlTZWxlY3RvckFsbCgiLm5hdi1wYW5lbCAubmF2LWxpbmsi
+KSx0LlIpCnMuSyhzLG5ldyBMLlZTKHIpKQpKLmRSKCQuYk4oKSkuaSgwLCJ2aXNpYmxlIil9LApBUjpm
+dW5jdGlvbihhLGIpe3ZhciBzLHIscT1iLmIKaWYocSE9bnVsbCl7cz10LmcKcj1zLmEocy5hKGEucGFy
+ZW50Tm9kZSkucGFyZW50Tm9kZSkKTC54bihyLnF1ZXJ5U2VsZWN0b3IoIjpzY29wZSA+IC5zdGF0dXMt
+aWNvbiIpLHEpCkwuQVIocixxKX19LApCRTpmdW5jdGlvbihhLGIsYyl7dmFyIHM9Ii5yZWdpb25zIixy
+PWRvY3VtZW50LHE9ci5xdWVyeVNlbGVjdG9yKHMpLHA9ci5xdWVyeVNlbGVjdG9yKCIuY29kZSIpCkou
+dEgocSxiLmEsJC5LRygpKQpKLnRIKHAsYi5iLCQuS0coKSkKTC5MSChhLGIuZCxjKQppZihiLmMubGVu
+Z3RoPDJlNSlMLnZVKCkKTC55WCgiLmNvZGUiLCEwKQpMLnlYKHMsITApfSwKdFg6ZnVuY3Rpb24oYSxi
+LGEwKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGU9Im1hdGVyaWFsLWljb25zIixkPWRv
+Y3VtZW50LGM9ZC5jcmVhdGVFbGVtZW50KCJ1bCIpCmEuYXBwZW5kQ2hpbGQoYykKZm9yKHM9Yi5sZW5n
+dGgscj10LlgscT10LloscD0wO3A8Yi5sZW5ndGg7Yi5sZW5ndGg9PT1zfHwoMCxILmxrKShiKSwrK3Ap
+e289YltwXQpuPWQuY3JlYXRlRWxlbWVudCgibGkiKQpjLmFwcGVuZENoaWxkKG4pCmlmKG8gaW5zdGFu
+Y2VvZiBMLnZ0KXtKLmRSKG4pLmkoMCwiZGlyIikKbi5zZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5T
+eShuZXcgVy5pNyhuKSkuUCgibmFtZSIpLG8uYykKbT1kLmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpuLmFw
+cGVuZENoaWxkKG0pCmw9Si5ZRShtKQpsLmduKG0pLmkoMCwiYXJyb3ciKQpsLnNoZihtLCImI3gyNUJD
+OyIpCms9ZC5jcmVhdGVFbGVtZW50KCJzcGFuIikKSi5kUihrKS5pKDAsZSkKay5pbm5lclRleHQ9ImZv
+bGRlcl9vcGVuIgpuLmFwcGVuZENoaWxkKGspCm4uYXBwZW5kQ2hpbGQoZC5jcmVhdGVUZXh0Tm9kZShv
+LmEpKQpMLnRYKG4sby5kLCExKQpMLmt6KG0pfWVsc2UgaWYobyBpbnN0YW5jZW9mIEwuY0Qpe2w9ZC5j
+cmVhdGVFbGVtZW50KCJzcGFuIikKSi5kUihsKS5pKDAsZSkKbC5pbm5lclRleHQ9Imluc2VydF9kcml2
+ZV9maWxlIgpuLmFwcGVuZENoaWxkKGwpCmo9ZC5jcmVhdGVFbGVtZW50KCJhIikKbi5hcHBlbmRDaGls
+ZChqKQpsPUouWUUoaikKbC5nbihqKS5pKDAsIm5hdi1saW5rIikKai5zZXRBdHRyaWJ1dGUoImRhdGEt
+IituZXcgVy5TeShuZXcgVy5pNyhqKSkuUCgibmFtZSIpLG8uYykKai5zZXRBdHRyaWJ1dGUoImhyZWYi
+LEwuUTQoby5kLFAuRmwocixyKSkpCmouYXBwZW5kQ2hpbGQoZC5jcmVhdGVUZXh0Tm9kZShvLmEpKQps
+PWwuZ1ZsKGopCmk9bC4kdGkKaD1pLkMoIn4oMSk/IikuYShuZXcgTC5URCgpKQpxLmEobnVsbCkKVy5K
+RShsLmEsbC5iLGgsITEsaS5jKQpnPW8uZQppZih0eXBlb2YgZyE9PSJudW1iZXIiKXJldHVybiBnLm9z
+KCkKaWYoZz4wKXtmPWQuY3JlYXRlRWxlbWVudCgic3BhbiIpCm4uYXBwZW5kQ2hpbGQoZikKSi5kUihm
+KS5pKDAsImVkaXQtY291bnQiKQpsPSIiK2crIiAiCmlmKGc9PT0xKWk9InByb3Bvc2VkIGVkaXQiCmVs
+c2UgaT0icHJvcG9zZWQgZWRpdHMiCmYuc2V0QXR0cmlidXRlKCJ0aXRsZSIsbCtpKQpmLmFwcGVuZENo
+aWxkKGQuY3JlYXRlVGV4dE5vZGUoQy5qbi53KGcpKSl9fX19LAp1ejpmdW5jdGlvbihhLGIsYyl7dmFy
+IHM9ZG9jdW1lbnQscj1zLmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpLHE9dC5rLHA9cS5DKCJ+KDEpPyIp
+LmEobmV3IEwubTIoYSxjKSkKdC5aLmEobnVsbCkKVy5KRShyLCJjbGljayIscCwhMSxxLmMpCnIuYXBw
+ZW5kQ2hpbGQocy5jcmVhdGVUZXh0Tm9kZShNLk9YKGEuYSkpKQpiLmFwcGVuZENoaWxkKHIpfSwKRno6
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGg9YS5hCmlmKGg9PW51bGwpcmV0
+dXJuCnM9ZG9jdW1lbnQKcj1zLmNyZWF0ZUVsZW1lbnQoInAiKQpxPWIuYXBwZW5kQ2hpbGQocikKcj1z
+LmNyZWF0ZUVsZW1lbnQoInNwYW4iKQpwPXQuaQpKLk11KHIsSC5WTShbInR5cGUtZGVzY3JpcHRpb24i
+XSxwKSkKci5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKCJBY3Rpb25zIikpCnEuYXBwZW5kQ2hp
+bGQocikKcS5hcHBlbmRDaGlsZChzLmNyZWF0ZVRleHROb2RlKCI6IikpCm89cy5jcmVhdGVFbGVtZW50
+KCJwIikKYi5hcHBlbmRDaGlsZChvKQpmb3Iocj1oLmxlbmd0aCxuPXQuUSxtPTA7bTxoLmxlbmd0aDto
+Lmxlbmd0aD09PXJ8fCgwLEgubGspKGgpLCsrbSl7bD1oW21dCms9cy5jcmVhdGVFbGVtZW50KCJhIikK
+by5hcHBlbmRDaGlsZChrKQprLmFwcGVuZENoaWxkKHMuY3JlYXRlVGV4dE5vZGUobC5hKSkKay5zZXRB
+dHRyaWJ1dGUoImhyZWYiLGwuYikKaj1uLmEoSC5WTShbImFkZC1oaW50LWxpbmsiLCJiZWZvcmUtYXBw
+bHkiLCJidXR0b24iXSxwKSkKaT1KLmRSKGspCmkuVjEoMCkKaS5GVigwLGopfX0sCkNDOmZ1bmN0aW9u
+KGE0LGE1LGE2KXt2YXIgcyxyLHEscCxvLG4sbSxsLGssaixpLGgsZyxmLGUsZCxjLGIsYSxhMCxhMSxh
+MixhMwpmb3Iocz1hNC5mLHI9cy5sZW5ndGgscT10LmkscD10LlEsbz0wO288cy5sZW5ndGg7cy5sZW5n
+dGg9PT1yfHwoMCxILmxrKShzKSwrK28pe249c1tvXQptPWRvY3VtZW50Cmw9bS5jcmVhdGVFbGVtZW50
+KCJwIikKaz1wLmEoSC5WTShbInRyYWNlIl0scSkpCmo9Si5kUihsKQpqLlYxKDApCmouRlYoMCxrKQpp
+PWE1LmFwcGVuZENoaWxkKGwpCmw9bS5jcmVhdGVFbGVtZW50KCJzcGFuIikKaz1wLmEoSC5WTShbInR5
+cGUtZGVzY3JpcHRpb24iXSxxKSkKaj1KLmRSKGwpCmouVjEoMCkKai5GVigwLGspCmwuYXBwZW5kQ2hp
+bGQobS5jcmVhdGVUZXh0Tm9kZShuLmEpKQppLmFwcGVuZENoaWxkKGwpCmkuYXBwZW5kQ2hpbGQobS5j
+cmVhdGVUZXh0Tm9kZSgiOiIpKQpsPW0uY3JlYXRlRWxlbWVudCgidWwiKQprPXAuYShILlZNKFsidHJh
+Y2UiXSxxKSkKaj1KLmRSKGwpCmouVjEoMCkKai5GVigwLGspCmg9aS5hcHBlbmRDaGlsZChsKQpmb3Io
+bD1uLmIsaz1sLmxlbmd0aCxnPTA7ZzxsLmxlbmd0aDtsLmxlbmd0aD09PWt8fCgwLEgubGspKGwpLCsr
+Zyl7Zj1sW2ddCmU9bS5jcmVhdGVFbGVtZW50KCJsaSIpCmguYXBwZW5kQ2hpbGQoZSkKZD1tLmNyZWF0
+ZUVsZW1lbnQoInNwYW4iKQpjPXAuYShILlZNKFsiZnVuY3Rpb24iXSxxKSkKaj1KLmRSKGQpCmouVjEo
+MCkKai5GVigwLGMpCmM9Zi5iCkwua0QoZCxjPT1udWxsPyJ1bmtub3duIjpjKQplLmFwcGVuZENoaWxk
+KGQpCmI9Zi5jCmlmKGIhPW51bGwpe2UuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9kZSgiICgiKSkK
+YT1iLmIKYTA9bS5jcmVhdGVFbGVtZW50KCJhIikKYTAuYXBwZW5kQ2hpbGQobS5jcmVhdGVUZXh0Tm9k
+ZShILkVqKGIuYykrIjoiK0guRWooYSkpKQphMC5zZXRBdHRyaWJ1dGUoImhyZWYiLGIuYSkKYTAuY2xh
+c3NMaXN0LmFkZCgibmF2LWxpbmsiKQplLmFwcGVuZENoaWxkKGEwKQplLmFwcGVuZENoaWxkKG0uY3Jl
+YXRlVGV4dE5vZGUoIikiKSl9ZS5hcHBlbmRDaGlsZChtLmNyZWF0ZVRleHROb2RlKCI6ICIpKQpkPWYu
+YQpMLmtEKGUsZD09bnVsbD8idW5rbm93biI6ZCkKZD1mLmQKaWYoZC5sZW5ndGghPT0wKXtjPW0uY3Jl
+YXRlRWxlbWVudCgicCIpCmExPXAuYShILlZNKFsiZHJhd2VyIiwiYmVmb3JlLWFwcGx5Il0scSkpCmo9
+Si5kUihjKQpqLlYxKDApCmouRlYoMCxhMSkKYTI9ZS5hcHBlbmRDaGlsZChjKQpmb3IoYz1kLmxlbmd0
+aCxhMz0wO2EzPGQubGVuZ3RoO2QubGVuZ3RoPT09Y3x8KDAsSC5saykoZCksKythMylMLnV6KGRbYTNd
+LGEyLGIpfX19fSwKVXM6ZnVuY3Rpb24oYSl7cmV0dXJuIEouVTYoYSkudGcoYSwiPyIpP0MueEIuTmoo
+YSwwLEMueEIuT1koYSwiPyIpKTphfSwKa0Q6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9SC5WTShiLnNw
+bGl0KCIuIiksdC5zKSxwPUMuTm0uZ3RIKHEpLG89ZG9jdW1lbnQKYS5hcHBlbmRDaGlsZChvLmNyZWF0
+ZVRleHROb2RlKHApKQpmb3IocD1ILnFDKHEsMSxudWxsLHQuTikscD1uZXcgSC5hNyhwLHAuZ0EocCks
+cC4kdGkuQygiYTc8YUwuRT4iKSkscz1KLllFKGEpO3AuRigpOyl7cj1wLmQKcy5ueihhLCJiZWZvcmVl
+bmQiLCImIzgyMDM7LiIsbnVsbCxudWxsKQphLmFwcGVuZENoaWxkKG8uY3JlYXRlVGV4dE5vZGUocikp
+fX0sCm1IOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKZm9yKHM9YS5sZW5ndGgscj0wO3I8YS5sZW5n
+dGg7YS5sZW5ndGg9PT1zfHwoMCxILmxrKShhKSwrK3Ipe3E9YVtyXQppZihxIGluc3RhbmNlb2YgTC52
+dCl7cD1MLm1IKHEuZCxiKQppZihwIT1udWxsKXJldHVybiBwfWVsc2UgaWYocS5jPT1iKXJldHVybiBx
+fXJldHVybiBudWxsfSwKZTpmdW5jdGlvbiBlKCl7fSwKVlc6ZnVuY3Rpb24gVlcoYSxiLGMpe3RoaXMu
+YT1hCnRoaXMuYj1iCnRoaXMuYz1jfSwKb1o6ZnVuY3Rpb24gb1ooKXt9LApqcjpmdW5jdGlvbiBqcigp
+e30sCnFsOmZ1bmN0aW9uIHFsKCl7fSwKSGk6ZnVuY3Rpb24gSGkoKXt9LApCVDpmdW5jdGlvbiBCVCgp
+e30sClBZOmZ1bmN0aW9uIFBZKCl7fSwKdTg6ZnVuY3Rpb24gdTgoKXt9LApMOmZ1bmN0aW9uIEwoKXt9
+LApXeDpmdW5jdGlvbiBXeChhLGIpe3RoaXMuYT1hCnRoaXMuYj1ifSwKQU86ZnVuY3Rpb24gQU8oYSl7
+dGhpcy5hPWF9LApkTjpmdW5jdGlvbiBkTihhKXt0aGlzLmE9YX0sCkhvOmZ1bmN0aW9uIEhvKGEpe3Ro
+aXMuYT1hfSwKeHo6ZnVuY3Rpb24geHooYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCklDOmZ1bmN0aW9u
+IElDKCl7fSwKZkM6ZnVuY3Rpb24gZkMoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sCm5UOmZ1bmN0aW9u
+IG5UKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sCk5ZOmZ1bmN0aW9uIE5ZKGEpe3Ro
+aXMuYT1hfSwKdWU6ZnVuY3Rpb24gdWUoKXt9LAplWDpmdW5jdGlvbiBlWCgpe30sCkVFOmZ1bmN0aW9u
+IEVFKGEsYixjKXt0aGlzLmE9YQp0aGlzLmI9Ygp0aGlzLmM9Y30sClFMOmZ1bmN0aW9uIFFMKGEsYil7
+dGhpcy5hPWEKdGhpcy5iPWJ9LApWUzpmdW5jdGlvbiBWUyhhKXt0aGlzLmE9YX0sClREOmZ1bmN0aW9u
+IFREKCl7fSwKbTI6ZnVuY3Rpb24gbTIoYSxiKXt0aGlzLmE9YQp0aGlzLmI9Yn0sClhBOmZ1bmN0aW9u
+IFhBKCl7fSwKWnM6ZnVuY3Rpb24oYSl7dmFyIHMscixxPUouVTYoYSkKaWYoTC5wMihILmgocS5xKGEs
+InR5cGUiKSkpPT09Qy5ZMil7cz1ILmgocS5xKGEsIm5hbWUiKSkKcj1ILmgocS5xKGEsInBhdGgiKSkK
+cT1xLnEoYSwic3VidHJlZSIpCnE9bmV3IEwudnQocT09bnVsbD9udWxsOkwubUsocSkscyxyKQpxLkxW
+KCkKcmV0dXJuIHF9ZWxzZXtzPUguaChxLnEoYSwibmFtZSIpKQpyPUguaChxLnEoYSwicGF0aCIpKQpy
+ZXR1cm4gbmV3IEwuY0QoSC5oKHEucShhLCJocmVmIikpLEgudVAocS5xKGEsImVkaXRDb3VudCIpKSxI
+Lnk4KHEucShhLCJ3YXNFeHBsaWNpdGx5T3B0ZWRPdXQiKSksTC52QihILnVQKHEucShhLCJtaWdyYXRp
+b25TdGF0dXMiKSkpLHMscil9fSwKbUs6ZnVuY3Rpb24oYSl7dmFyIHMscj1ILlZNKFtdLHQuY1EpCmZv
+cihzPUouSVQodC5VLmEoYSkpO3MuRigpOylyLnB1c2goTC5acyhzLmdsKCkpKQpyZXR1cm4gcn0sClZE
+OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT1ILlZNKFtdLHQuRykKZm9yKHM9YS5sZW5ndGgscj0wO3I8YS5s
+ZW5ndGg7YS5sZW5ndGg9PT1zfHwoMCxILmxrKShhKSwrK3IpcS5wdXNoKGFbcl0uTHQoKSkKcmV0dXJu
+IHF9LAp2QjpmdW5jdGlvbihhKXtpZihhPT1udWxsKXJldHVybiBudWxsCmlmKGE+Pj4wIT09YXx8YT49
+NClyZXR1cm4gSC5PSChDLmwwLGEpCnJldHVybiBDLmwwW2FdfSwKcDI6ZnVuY3Rpb24oYSl7c3dpdGNo
+KGEpe2Nhc2UiZGlyZWN0b3J5IjpyZXR1cm4gQy5ZMgpjYXNlImZpbGUiOnJldHVybiBDLnJmCmRlZmF1
+bHQ6dGhyb3cgSC5iKFAuUFYoIlVucmVjb2duaXplZCBuYXZpZ2F0aW9uIHRyZWUgbm9kZSB0eXBlOiAi
+K0guRWooYSkpKX19LAp2dDpmdW5jdGlvbiB2dChhLGIsYyl7dmFyIF89dGhpcwpfLmQ9YQpfLmE9Ygpf
+LmI9bnVsbApfLmM9Y30sCmNEOmZ1bmN0aW9uIGNEKGEsYixjLGQsZSxmKXt2YXIgXz10aGlzCl8uZD1h
+Cl8uZT1iCl8uZj1jCl8ucj1kCl8uYT1lCl8uYj1udWxsCl8uYz1mfSwKRDg6ZnVuY3Rpb24gRDgoKXt9
+LApPOTpmdW5jdGlvbiBPOShhKXt0aGlzLmI9YX0sCkdiOmZ1bmN0aW9uIEdiKGEsYil7dGhpcy5hPWEK
+dGhpcy5iPWJ9LApJVjpmdW5jdGlvbiBJVihhLGIsYyxkKXt2YXIgXz10aGlzCl8uZD1hCl8uZT1iCl8u
+Zj1jCl8ucj1kfX0sWD17CkNMOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuPWIueFooYSkKYi5o
+SyhhKQppZihuIT1udWxsKWE9Si5LVihhLG4ubGVuZ3RoKQpzPXQucwpyPUguVk0oW10scykKcT1ILlZN
+KFtdLHMpCnM9YS5sZW5ndGgKaWYocyE9PTAmJmIucjQoQy54Qi5XKGEsMCkpKXtpZigwPj1zKXJldHVy
+biBILk9IKGEsMCkKQy5ObS5pKHEsYVswXSkKcD0xfWVsc2V7Qy5ObS5pKHEsIiIpCnA9MH1mb3Iobz1w
+O288czsrK28paWYoYi5yNChDLnhCLlcoYSxvKSkpe0MuTm0uaShyLEMueEIuTmooYSxwLG8pKQpDLk5t
+LmkocSxhW29dKQpwPW8rMX1pZihwPHMpe0MuTm0uaShyLEMueEIueW4oYSxwKSkKQy5ObS5pKHEsIiIp
+fXJldHVybiBuZXcgWC5XRChiLG4scixxKX0sCldEOmZ1bmN0aW9uIFdEKGEsYixjLGQpe3ZhciBfPXRo
+aXMKXy5hPWEKXy5iPWIKXy5kPWMKXy5lPWR9LApJNzpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFguZHYo
+YSl9LApkdjpmdW5jdGlvbiBkdihhKXt0aGlzLmE9YX19LE89ewpSaDpmdW5jdGlvbigpe3ZhciBzLHI9
+bnVsbAppZihQLnVvKCkuZ0ZpKCkhPT0iZmlsZSIpcmV0dXJuICQuRWIoKQpzPVAudW8oKQppZighQy54
+Qi5UYyhzLmdJaShzKSwiLyIpKXJldHVybiAkLkViKCkKaWYoUC5LTChyLCJhL2IiLHIscixyLHIsciku
+dDQoKT09PSJhXFxiIilyZXR1cm4gJC5LaygpCnJldHVybiAkLmJEKCl9LAp6TDpmdW5jdGlvbiB6TCgp
+e319LEU9e09GOmZ1bmN0aW9uIE9GKGEsYixjKXt0aGlzLmQ9YQp0aGlzLmU9Ygp0aGlzLmY9Y319LEY9
+e3J1OmZ1bmN0aW9uIHJ1KGEsYixjLGQpe3ZhciBfPXRoaXMKXy5kPWEKXy5lPWIKXy5mPWMKXy5yPWR9
+fSxEPXsKYWI6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPW51bGwKdHJ5e289UC51bygpfWNhdGNoKHMp
+e2lmKHQuZzguYihILlJ1KHMpKSl7cj0kLkZmCmlmKHIhPW51bGwpcmV0dXJuIHIKdGhyb3cgc31lbHNl
+IHRocm93IHN9aWYoSi5STShvLCQuSTYpKXtyPSQuRmYKci50b1N0cmluZwpyZXR1cm4gcn0kLkk2PW8K
+aWYoJC5IaygpPT0kLkViKCkpcj0kLkZmPW8uWkkoIi4iKS53KDApCmVsc2V7cT1vLnQ0KCkKcD1xLmxl
+bmd0aC0xCnI9JC5GZj1wPT09MD9xOkMueEIuTmoocSwwLHApfXIudG9TdHJpbmcKcmV0dXJuIHJ9fQp2
+YXIgdz1bQyxILEosUCxXLE0sVSxCLFQsTCxYLE8sRSxGLERdCmh1bmtIZWxwZXJzLnNldEZ1bmN0aW9u
+TmFtZXNJZk5lY2Vzc2FyeSh3KQp2YXIgJD17fQpILkZLLnByb3RvdHlwZT17fQpKLkd2LnByb3RvdHlw
+ZT17CkROOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGE9PT1ifSwKZ2lPOmZ1bmN0aW9uKGEpe3JldHVybiBI
+LmVRKGEpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4iSW5zdGFuY2Ugb2YgJyIrSC5FaihILk0oYSkpKyIn
+In0sCmU3OmZ1bmN0aW9uKGEsYil7dC5vLmEoYikKdGhyb3cgSC5iKFAubHIoYSxiLmdXYSgpLGIuZ25k
+KCksYi5nVm0oKSkpfX0KSi55RS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmco
+YSl9LApnaU86ZnVuY3Rpb24oYSl7cmV0dXJuIGE/NTE5MDE4OjIxODE1OX0sCiRpYTI6MX0KSi53ZS5w
+cm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe3JldHVybiBudWxsPT1ifSwKdzpmdW5jdGlvbihhKXty
+ZXR1cm4ibnVsbCJ9LApnaU86ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LAplNzpmdW5jdGlvbihhLGIpe3Jl
+dHVybiB0aGlzLlNqKGEsdC5vLmEoYikpfSwKJGljODoxfQpKLk1GLnByb3RvdHlwZT17CmdpTzpmdW5j
+dGlvbihhKXtyZXR1cm4gMH0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFN0cmluZyhhKX0sCiRpdm06MX0K
+Si5pQy5wcm90b3R5cGU9e30KSi5rZC5wcm90b3R5cGU9e30KSi5jNS5wcm90b3R5cGU9ewp3OmZ1bmN0
+aW9uKGEpe3ZhciBzPWFbJC53KCldCmlmKHM9PW51bGwpcmV0dXJuIHRoaXMudChhKQpyZXR1cm4iSmF2
+YVNjcmlwdCBmdW5jdGlvbiBmb3IgIitILkVqKEouaihzKSl9LAokaUVIOjF9CkouamQucHJvdG90eXBl
+PXsKZHI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEgualYoYSxILnQ2KGEpLkMoIkA8MT4iKS5LcShi
+KS5DKCJqVjwxLDI+IikpfSwKaTpmdW5jdGlvbihhLGIpe0gudDYoYSkuYy5hKGIpCmlmKCEhYS5maXhl
+ZCRsZW5ndGgpSC52KFAuTDQoImFkZCIpKQphLnB1c2goYil9LApXNDpmdW5jdGlvbihhLGIpe3ZhciBz
+CmlmKCEhYS5maXhlZCRsZW5ndGgpSC52KFAuTDQoInJlbW92ZUF0IikpCnM9YS5sZW5ndGgKaWYoYj49
+cyl0aHJvdyBILmIoUC5PNyhiLG51bGwpKQpyZXR1cm4gYS5zcGxpY2UoYiwxKVswXX0sClVHOmZ1bmN0
+aW9uKGEsYixjKXt2YXIgcyxyCkgudDYoYSkuQygiY1g8MT4iKS5hKGMpCmlmKCEhYS5maXhlZCRsZW5n
+dGgpSC52KFAuTDQoImluc2VydEFsbCIpKQpQLndBKGIsMCxhLmxlbmd0aCwiaW5kZXgiKQppZighdC5k
+LmIoYykpYz1KLlJYKGMpCnM9Si5IbShjKQphLmxlbmd0aD1hLmxlbmd0aCtzCnI9YitzCnRoaXMuWVco
+YSxyLGEubGVuZ3RoLGEsYikKdGhpcy52ZyhhLGIscixjKX0sCkZWOmZ1bmN0aW9uKGEsYil7dmFyIHMK
+SC50NihhKS5DKCJjWDwxPiIpLmEoYikKaWYoISFhLmZpeGVkJGxlbmd0aClILnYoUC5MNCgiYWRkQWxs
+IikpCmlmKEFycmF5LmlzQXJyYXkoYikpe3RoaXMuS2goYSxiKQpyZXR1cm59Zm9yKHM9Si5JVChiKTtz
+LkYoKTspYS5wdXNoKHMuZ2woKSl9LApLaDpmdW5jdGlvbihhLGIpe3ZhciBzLHIKdC5iLmEoYikKcz1i
+Lmxlbmd0aAppZihzPT09MClyZXR1cm4KaWYoYT09PWIpdGhyb3cgSC5iKFAuYTQoYSkpCmZvcihyPTA7
+cjxzOysrcilhLnB1c2goYltyXSl9LApFMjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9SC50NihhKQpyZXR1
+cm4gbmV3IEgubEooYSxzLktxKGMpLkMoIjEoMikiKS5hKGIpLHMuQygiQDwxPiIpLktxKGMpLkMoImxK
+PDEsMj4iKSl9LAprOmZ1bmN0aW9uKGEsYil7dmFyIHMscj1QLk84KGEubGVuZ3RoLCIiLCExLHQuTikK
+Zm9yKHM9MDtzPGEubGVuZ3RoOysrcyl0aGlzLlk1KHIscyxILkVqKGFbc10pKQpyZXR1cm4gci5qb2lu
+KGIpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5xQyhhLGIsbnVsbCxILnQ2KGEpLmMpfSwKTjA6
+ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxCmQuYShiKQpILnQ2KGEpLktxKGQpLkMoIjEoMSwyKSIp
+LmEoYykKcz1hLmxlbmd0aApmb3Iocj1iLHE9MDtxPHM7KytxKXtyPWMuJDIocixhW3FdKQppZihhLmxl
+bmd0aCE9PXMpdGhyb3cgSC5iKFAuYTQoYSkpfXJldHVybiByfSwKSHQ6ZnVuY3Rpb24oYSxiKXt2YXIg
+cyxyLHEscCxvCkgudDYoYSkuQygiYTIoMSkiKS5hKGIpCnM9YS5sZW5ndGgKZm9yKHI9bnVsbCxxPSEx
+LHA9MDtwPHM7KytwKXtvPWFbcF0KaWYoSC5vVChiLiQxKG8pKSl7aWYocSl0aHJvdyBILmIoSC5BbSgp
+KQpyPW8KcT0hMH1pZihzIT09YS5sZW5ndGgpdGhyb3cgSC5iKFAuYTQoYSkpfWlmKHEpcmV0dXJuIHIK
+dGhyb3cgSC5iKEguV3AoKSl9LApFOmZ1bmN0aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1
+cm4gSC5PSChhLGIpCnJldHVybiBhW2JdfSwKZ3RIOmZ1bmN0aW9uKGEpe2lmKGEubGVuZ3RoPjApcmV0
+dXJuIGFbMF0KdGhyb3cgSC5iKEguV3AoKSl9LApnclo6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgK
+aWYocz4wKXJldHVybiBhW3MtMV0KdGhyb3cgSC5iKEguV3AoKSl9LApZVzpmdW5jdGlvbihhLGIsYyxk
+LGUpe3ZhciBzLHIscSxwLG8KSC50NihhKS5DKCJjWDwxPiIpLmEoZCkKaWYoISFhLmltbXV0YWJsZSRs
+aXN0KUgudihQLkw0KCJzZXRSYW5nZSIpKQpQLmpCKGIsYyxhLmxlbmd0aCkKcz1jLWIKaWYocz09PTAp
+cmV0dXJuClAuazEoZSwic2tpcENvdW50IikKaWYodC5qLmIoZCkpe3I9ZApxPWV9ZWxzZXtyPUouQTUo
+ZCxlKS50dCgwLCExKQpxPTB9cD1KLlU2KHIpCmlmKHErcz5wLmdBKHIpKXRocm93IEguYihILmFyKCkp
+CmlmKHE8Yilmb3Iobz1zLTE7bz49MDstLW8pYVtiK29dPXAucShyLHErbykKZWxzZSBmb3Iobz0wO288
+czsrK28pYVtiK29dPXAucShyLHErbyl9LAp2ZzpmdW5jdGlvbihhLGIsYyxkKXtyZXR1cm4gdGhpcy5Z
+VyhhLGIsYyxkLDApfSwKVnI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCkgudDYoYSkuQygiYTIoMSkiKS5h
+KGIpCnM9YS5sZW5ndGgKZm9yKHI9MDtyPHM7KytyKXtpZihILm9UKGIuJDEoYVtyXSkpKXJldHVybiEw
+CmlmKGEubGVuZ3RoIT09cyl0aHJvdyBILmIoUC5hNChhKSl9cmV0dXJuITF9LAp0ZzpmdW5jdGlvbihh
+LGIpe3ZhciBzCmZvcihzPTA7czxhLmxlbmd0aDsrK3MpaWYoSi5STShhW3NdLGIpKXJldHVybiEwCnJl
+dHVybiExfSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aD09PTB9LApnb3I6ZnVuY3Rpb24o
+YSl7cmV0dXJuIGEubGVuZ3RoIT09MH0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFAuV0UoYSwiWyIsIl0i
+KX0sCnR0OmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5WTShhLnNsaWNlKDApLEgudDYoYSkpCnJldHVybiBz
+fSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9LApnbTpmdW5jdGlvbihhKXtyZXR1
+cm4gbmV3IEoubTEoYSxhLmxlbmd0aCxILnQ2KGEpLkMoIm0xPDE+IikpfSwKZ2lPOmZ1bmN0aW9uKGEp
+e3JldHVybiBILmVRKGEpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKc0E6ZnVuY3Rp
+b24oYSxiKXtpZighIWEuZml4ZWQkbGVuZ3RoKUgudihQLkw0KCJzZXQgbGVuZ3RoIikpCmlmKGI8MCl0
+aHJvdyBILmIoUC5URShiLDAsbnVsbCwibmV3TGVuZ3RoIixudWxsKSkKYS5sZW5ndGg9Yn0sCnE6ZnVu
+Y3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+PWEubGVuZ3RofHxiPDApdGhyb3cgSC5iKEguSFkoYSxiKSkK
+cmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIsYyl7SC50NihhKS5jLmEoYykKaWYoISFhLmltbXV0
+YWJsZSRsaXN0KUgudihQLkw0KCJpbmRleGVkIHNldCIpKQppZihiPj1hLmxlbmd0aHx8YjwwKXRocm93
+IEguYihILkhZKGEsYikpCmFbYl09Y30sCiRpYlE6MSwKJGljWDoxLAokaXpNOjF9CkouUG8ucHJvdG90
+eXBlPXt9CkoubTEucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5j
+dGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxwPXEubGVuZ3RoCmlmKHIuYiE9PXApdGhyb3cgSC5iKEgu
+bGsocSkpCnM9ci5jCmlmKHM+PXApe3Iuc00obnVsbCkKcmV0dXJuITF9ci5zTShxW3NdKTsrK3IuYwpy
+ZXR1cm4hMH0sCnNNOmZ1bmN0aW9uKGEpe3RoaXMuZD10aGlzLiR0aS5DKCIxPyIpLmEoYSl9LAokaUFu
+OjF9CkoucUkucHJvdG90eXBlPXsKelE6ZnVuY3Rpb24oYSl7aWYoYT4wKXtpZihhIT09MS8wKXJldHVy
+biBNYXRoLnJvdW5kKGEpfWVsc2UgaWYoYT4tMS8wKXJldHVybiAwLU1hdGgucm91bmQoMC1hKQp0aHJv
+dyBILmIoUC5MNCgiIithKyIucm91bmQoKSIpKX0sCnc6ZnVuY3Rpb24oYSl7aWYoYT09PTAmJjEvYTww
+KXJldHVybiItMC4wIgplbHNlIHJldHVybiIiK2F9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAs
+bz1hfDAKaWYoYT09PW8pcmV0dXJuIG8mNTM2ODcwOTExCnM9TWF0aC5hYnMoYSkKcj1NYXRoLmxvZyhz
+KS8wLjY5MzE0NzE4MDU1OTk0NTN8MApxPU1hdGgucG93KDIscikKcD1zPDE/cy9xOnEvcwpyZXR1cm4o
+KHAqOTAwNzE5OTI1NDc0MDk5MnwwKSsocCozNTQyMjQzMTgxMTc2NTIxfDApKSo1OTkxOTcrcioxMjU5
+JjUzNjg3MDkxMX0sCnpZOmZ1bmN0aW9uKGEsYil7dmFyIHM9YSViCmlmKHM9PT0wKXJldHVybiAwCmlm
+KHM+MClyZXR1cm4gcwppZihiPDApcmV0dXJuIHMtYgplbHNlIHJldHVybiBzK2J9LApCVTpmdW5jdGlv
+bihhLGIpe3JldHVybihhfDApPT09YT9hL2J8MDp0aGlzLkRKKGEsYil9LApESjpmdW5jdGlvbihhLGIp
+e3ZhciBzPWEvYgppZihzPj0tMjE0NzQ4MzY0OCYmczw9MjE0NzQ4MzY0NylyZXR1cm4gc3wwCmlmKHM+
+MCl7aWYocyE9PTEvMClyZXR1cm4gTWF0aC5mbG9vcihzKX1lbHNlIGlmKHM+LTEvMClyZXR1cm4gTWF0
+aC5jZWlsKHMpCnRocm93IEguYihQLkw0KCJSZXN1bHQgb2YgdHJ1bmNhdGluZyBkaXZpc2lvbiBpcyAi
+K0guRWoocykrIjogIitILkVqKGEpKyIgfi8gIitiKSl9LAp3RzpmdW5jdGlvbihhLGIpe3ZhciBzCmlm
+KGE+MClzPXRoaXMucDMoYSxiKQplbHNle3M9Yj4zMT8zMTpiCnM9YT4+cz4+PjB9cmV0dXJuIHN9LApi
+ZjpmdW5jdGlvbihhLGIpe2lmKGI8MCl0aHJvdyBILmIoSC50TChiKSkKcmV0dXJuIHRoaXMucDMoYSxi
+KX0sCnAzOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGI+MzE/MDphPj4+Yn0sCiRpQ1A6MSwKJGlaWjoxfQpK
+LmJVLnByb3RvdHlwZT17JGlJZjoxfQpKLlZBLnByb3RvdHlwZT17fQpKLkRyLnByb3RvdHlwZT17Ck8y
+OmZ1bmN0aW9uKGEsYil7aWYoYjwwKXRocm93IEguYihILkhZKGEsYikpCmlmKGI+PWEubGVuZ3RoKUgu
+dihILkhZKGEsYikpCnJldHVybiBhLmNoYXJDb2RlQXQoYil9LApXOmZ1bmN0aW9uKGEsYil7aWYoYj49
+YS5sZW5ndGgpdGhyb3cgSC5iKEguSFkoYSxiKSkKcmV0dXJuIGEuY2hhckNvZGVBdChiKX0sCmRkOmZ1
+bmN0aW9uKGEsYil7cmV0dXJuIG5ldyBILnVuKGIsYSwwKX0sCmg6ZnVuY3Rpb24oYSxiKXtpZih0eXBl
+b2YgYiE9InN0cmluZyIpdGhyb3cgSC5iKFAuTDMoYixudWxsLG51bGwpKQpyZXR1cm4gYStifSwKVGM6
+ZnVuY3Rpb24oYSxiKXt2YXIgcz1iLmxlbmd0aCxyPWEubGVuZ3RoCmlmKHM+cilyZXR1cm4hMQpyZXR1
+cm4gYj09PXRoaXMueW4oYSxyLXMpfSwKaTc6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHM9UC5qQihiLGMs
+YS5sZW5ndGgpLHI9YS5zdWJzdHJpbmcoMCxiKSxxPWEuc3Vic3RyaW5nKHMpCnJldHVybiByK2QrcX0s
+ClFpOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwppZihjPDB8fGM+YS5sZW5ndGgpdGhyb3cgSC5iKFAuVEUo
+YywwLGEubGVuZ3RoLG51bGwsbnVsbCkpCnM9YytiLmxlbmd0aAppZihzPmEubGVuZ3RoKXJldHVybiEx
+CnJldHVybiBiPT09YS5zdWJzdHJpbmcoYyxzKX0sCm5DOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMu
+UWkoYSxiLDApfSwKTmo6ZnVuY3Rpb24oYSxiLGMpe2lmKGM9PW51bGwpYz1hLmxlbmd0aAppZihiPDAp
+dGhyb3cgSC5iKFAuTzcoYixudWxsKSkKaWYoYj5jKXRocm93IEguYihQLk83KGIsbnVsbCkpCmlmKGM+
+YS5sZW5ndGgpdGhyb3cgSC5iKFAuTzcoYyxudWxsKSkKcmV0dXJuIGEuc3Vic3RyaW5nKGIsYyl9LAp5
+bjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLk5qKGEsYixudWxsKX0sCmhjOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBhLnRvTG93ZXJDYXNlKCl9LApiUzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscD1hLnRyaW0oKSxv
+PXAubGVuZ3RoCmlmKG89PT0wKXJldHVybiBwCmlmKHRoaXMuVyhwLDApPT09MTMzKXtzPUoubW0ocCwx
+KQppZihzPT09bylyZXR1cm4iIn1lbHNlIHM9MApyPW8tMQpxPXRoaXMuTzIocCxyKT09PTEzMz9KLmMx
+KHAscik6bwppZihzPT09MCYmcT09PW8pcmV0dXJuIHAKcmV0dXJuIHAuc3Vic3RyaW5nKHMscSl9LApU
+OmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZigwPj1iKXJldHVybiIiCmlmKGI9PT0xfHxhLmxlbmd0aD09
+PTApcmV0dXJuIGEKaWYoYiE9PWI+Pj4wKXRocm93IEguYihDLkVxKQpmb3Iocz1hLHI9IiI7ITA7KXtp
+ZigoYiYxKT09PTEpcj1zK3IKYj1iPj4+MQppZihiPT09MClicmVhawpzKz1zfXJldHVybiByfSwKWFU6
+ZnVuY3Rpb24oYSxiLGMpe3ZhciBzCmlmKGM8MHx8Yz5hLmxlbmd0aCl0aHJvdyBILmIoUC5URShjLDAs
+YS5sZW5ndGgsbnVsbCxudWxsKSkKcz1hLmluZGV4T2YoYixjKQpyZXR1cm4gc30sCk9ZOmZ1bmN0aW9u
+KGEsYil7cmV0dXJuIHRoaXMuWFUoYSxiLDApfSwKUGs6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIKaWYo
+Yz09bnVsbCljPWEubGVuZ3RoCmVsc2UgaWYoYzwwfHxjPmEubGVuZ3RoKXRocm93IEguYihQLlRFKGMs
+MCxhLmxlbmd0aCxudWxsLG51bGwpKQpzPWIubGVuZ3RoCnI9YS5sZW5ndGgKaWYoYytzPnIpYz1yLXMK
+cmV0dXJuIGEubGFzdEluZGV4T2YoYixjKX0sCmNuOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuUGso
+YSxiLG51bGwpfSwKSXM6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPWEubGVuZ3RoCmlmKGM+cyl0aHJvdyBI
+LmIoUC5URShjLDAscyxudWxsLG51bGwpKQpyZXR1cm4gSC5TUShhLGIsYyl9LAp0ZzpmdW5jdGlvbihh
+LGIpe3JldHVybiB0aGlzLklzKGEsYiwwKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIGF9LApnaU86ZnVu
+Y3Rpb24oYSl7dmFyIHMscixxCmZvcihzPWEubGVuZ3RoLHI9MCxxPTA7cTxzOysrcSl7cj1yK2EuY2hh
+ckNvZGVBdChxKSY1MzY4NzA5MTEKcj1yKygociY1MjQyODcpPDwxMCkmNTM2ODcwOTExCnJePXI+PjZ9
+cj1yKygociY2NzEwODg2Myk8PDMpJjUzNjg3MDkxMQpyXj1yPj4xMQpyZXR1cm4gcisoKHImMTYzODMp
+PDwxNSkmNTM2ODcwOTExfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlv
+bihhLGIpe0gudVAoYikKaWYoYj49YS5sZW5ndGh8fCExKXRocm93IEguYihILkhZKGEsYikpCnJldHVy
+biBhW2JdfSwKJGl2WDoxLAokaXFVOjF9CkguQlIucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFy
+IHM9SC5MaCh0aGlzKQpyZXR1cm4gbmV3IEguRTcoSi5JVCh0aGlzLmdPTigpKSxzLkMoIkA8MT4iKS5L
+cShzLlFbMV0pLkMoIkU3PDEsMj4iKSl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gSi5IbSh0aGlzLmdP
+TigpKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmdPTigpKX0sCmdvcjpmdW5jdGlv
+bihhKXtyZXR1cm4gSi5GNyh0aGlzLmdPTigpKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHM9SC5MaCh0
+aGlzKQpyZXR1cm4gSC5HSihKLkE1KHRoaXMuZ09OKCksYikscy5jLHMuUVsxXSl9LApFOmZ1bmN0aW9u
+KGEsYil7cmV0dXJuIEguTGgodGhpcykuUVsxXS5hKEouR0EodGhpcy5nT04oKSxiKSl9LAp3OmZ1bmN0
+aW9uKGEpe3JldHVybiBKLmoodGhpcy5nT04oKSl9fQpILkU3LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24o
+KXtyZXR1cm4gdGhpcy5hLkYoKX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuJHRpLlFbMV0uYSh0
+aGlzLmEuZ2woKSl9LAokaUFuOjF9CkguWnkucHJvdG90eXBlPXsKZ09OOmZ1bmN0aW9uKCl7cmV0dXJu
+IHRoaXMuYX19Ckgub2wucHJvdG90eXBlPXskaWJROjF9CkguVXEucHJvdG90eXBlPXsKcTpmdW5jdGlv
+bihhLGIpe3JldHVybiB0aGlzLiR0aS5RWzFdLmEoSi54OSh0aGlzLmEsSC51UChiKSkpfSwKWTU6ZnVu
+Y3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMuJHRpCkoudTkodGhpcy5hLGIscy5jLmEocy5RWzFdLmEoYykp
+KX0sCiRpYlE6MSwKJGl6TToxfQpILmpWLnByb3RvdHlwZT17CmRyOmZ1bmN0aW9uKGEsYil7cmV0dXJu
+IG5ldyBILmpWKHRoaXMuYSx0aGlzLiR0aS5DKCJAPDE+IikuS3EoYikuQygialY8MSwyPiIpKX0sCmdP
+TjpmdW5jdGlvbigpe3JldHVybiB0aGlzLmF9fQpILm4ucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2
+YXIgcz10aGlzLmEKcmV0dXJuIHMhPW51bGw/IkxhdGVJbml0aWFsaXphdGlvbkVycm9yOiAiK3M6Ikxh
+dGVJbml0aWFsaXphdGlvbkVycm9yIn19CkgucjMucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIg
+cz0iUmVhY2hhYmlsaXR5RXJyb3I6ICIrdGhpcy5hCnJldHVybiBzfX0KSC5xai5wcm90b3R5cGU9ewpn
+QTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4g
+Qy54Qi5PMih0aGlzLmEsSC51UChiKSl9fQpILkdNLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0
+dXJuIk51bGwgaXMgbm90IGEgdmFsaWQgdmFsdWUgZm9yIHRoZSBwYXJhbWV0ZXIgJyIrdGhpcy5hKyIn
+IG9mIHR5cGUgJyIrSC5LeCh0aGlzLiR0aS5jKS53KDApKyInIn19CkguYlEucHJvdG90eXBlPXt9Ckgu
+YUwucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcwpyZXR1cm4gbmV3IEguYTcocyxz
+LmdBKHMpLEguTGgocykuQygiYTc8YUwuRT4iKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
+Z0EodGhpcyk9PT0wfSwKazpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPXRoaXMsbz1wLmdBKHApCmlm
+KGIubGVuZ3RoIT09MCl7aWYobz09PTApcmV0dXJuIiIKcz1ILkVqKHAuRSgwLDApKQppZihvIT09cC5n
+QShwKSl0aHJvdyBILmIoUC5hNChwKSkKZm9yKHI9cyxxPTE7cTxvOysrcSl7cj1yK2IrSC5FaihwLkUo
+MCxxKSkKaWYobyE9PXAuZ0EocCkpdGhyb3cgSC5iKFAuYTQocCkpfXJldHVybiByLmNoYXJDb2RlQXQo
+MCk9PTA/cjpyfWVsc2V7Zm9yKHE9MCxyPSIiO3E8bzsrK3Epe3IrPUguRWoocC5FKDAscSkpCmlmKG8h
+PT1wLmdBKHApKXRocm93IEguYihQLmE0KHApKX1yZXR1cm4gci5jaGFyQ29kZUF0KDApPT0wP3I6cn19
+LApldjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLkdHKDAsSC5MaCh0aGlzKS5DKCJhMihhTC5FKSIp
+LmEoYikpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILmxK
+KHRoaXMscy5LcShjKS5DKCIxKGFMLkUpIikuYShiKSxzLkMoIkA8YUwuRT4iKS5LcShjKS5DKCJsSjwx
+LDI+IikpfSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5xQyh0aGlzLGIsbnVsbCxILkxoKHRoaXMp
+LkMoImFMLkUiKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVybiBQLlkxKHRoaXMsITAsSC5MaCh0aGlz
+KS5DKCJhTC5FIikpfSwKYnI6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMudHQoYSwhMCl9fQpILm5ILnBy
+b3RvdHlwZT17CkhkOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHI9dGhpcy5iClAuazEociwic3RhcnQi
+KQpzPXRoaXMuYwppZihzIT1udWxsKXtQLmsxKHMsImVuZCIpCmlmKHI+cyl0aHJvdyBILmIoUC5URShy
+LDAscywic3RhcnQiLG51bGwpKX19LApnVUQ6ZnVuY3Rpb24oKXt2YXIgcz1KLkhtKHRoaXMuYSkscj10
+aGlzLmMKaWYocj09bnVsbHx8cj5zKXJldHVybiBzCnJldHVybiByfSwKZ0FzOmZ1bmN0aW9uKCl7dmFy
+IHM9Si5IbSh0aGlzLmEpLHI9dGhpcy5iCmlmKHI+cylyZXR1cm4gcwpyZXR1cm4gcn0sCmdBOmZ1bmN0
+aW9uKGEpe3ZhciBzLHI9Si5IbSh0aGlzLmEpLHE9dGhpcy5iCmlmKHE+PXIpcmV0dXJuIDAKcz10aGlz
+LmMKaWYocz09bnVsbHx8cz49cilyZXR1cm4gci1xCmlmKHR5cGVvZiBzIT09Im51bWJlciIpcmV0dXJu
+IHMuSE4oKQpyZXR1cm4gcy1xfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMscj1zLmdBcygpK2IK
+aWYoYjwwfHxyPj1zLmdVRCgpKXRocm93IEguYihQLkNmKGIscywiaW5kZXgiLG51bGwsbnVsbCkpCnJl
+dHVybiBKLkdBKHMuYSxyKX0sCmVSOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMKUC5rMShiLCJj
+b3VudCIpCnM9cS5iK2IKcj1xLmMKaWYociE9bnVsbCYmcz49cilyZXR1cm4gbmV3IEguTUIocS4kdGku
+QygiTUI8MT4iKSkKcmV0dXJuIEgucUMocS5hLHMscixxLiR0aS5jKX0sCnR0OmZ1bmN0aW9uKGEsYil7
+dmFyIHMscixxLHA9dGhpcyxvPXAuYixuPXAuYSxtPUouVTYobiksbD1tLmdBKG4pLGs9cC5jCmlmKGsh
+PW51bGwmJms8bClsPWsKaWYodHlwZW9mIGwhPT0ibnVtYmVyIilyZXR1cm4gbC5ITigpCnM9bC1vCmlm
+KHM8PTApe249Si5RaSgwLHAuJHRpLmMpCnJldHVybiBufXI9UC5POChzLG0uRShuLG8pLCExLHAuJHRp
+LmMpCmZvcihxPTE7cTxzOysrcSl7Qy5ObS5ZNShyLHEsbS5FKG4sbytxKSkKaWYobS5nQShuKTxsKXRo
+cm93IEguYihQLmE0KHApKX1yZXR1cm4gcn19CkguYTcucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXty
+ZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPXIuYSxwPUouVTYocSksbz1w
+LmdBKHEpCmlmKHIuYiE9PW8pdGhyb3cgSC5iKFAuYTQocSkpCnM9ci5jCmlmKHM+PW8pe3Iuc0kobnVs
+bCkKcmV0dXJuITF9ci5zSShwLkUocSxzKSk7KytyLmMKcmV0dXJuITB9LApzSTpmdW5jdGlvbihhKXt0
+aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpILmkxLnByb3RvdHlwZT17CmdtOmZ1
+bmN0aW9uKGEpe3ZhciBzPUguTGgodGhpcykKcmV0dXJuIG5ldyBILk1IKEouSVQodGhpcy5hKSx0aGlz
+LmIscy5DKCJAPDE+IikuS3Eocy5RWzFdKS5DKCJNSDwxLDI+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0
+dXJuIEouSG0odGhpcy5hKX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gSi51VSh0aGlzLmEpfSwKRTpm
+dW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmIuJDEoSi5HQSh0aGlzLmEsYikpfX0KSC54eS5wcm90b3R5
+cGU9eyRpYlE6MX0KSC5NSC5wcm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYgpp
+ZihyLkYoKSl7cy5zSShzLmMuJDEoci5nbCgpKSkKcmV0dXJuITB9cy5zSShudWxsKQpyZXR1cm4hMX0s
+CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYX0sCnNJOmZ1bmN0aW9uKGEpe3RoaXMuYT10aGlzLiR0
+aS5DKCIyPyIpLmEoYSl9fQpILmxKLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBKLkht
+KHRoaXMuYSl9LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuYi4kMShKLkdBKHRoaXMuYSxiKSl9
+fQpILlU1LnByb3RvdHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5TTyhKLklUKHRoaXMu
+YSksdGhpcy5iLHRoaXMuJHRpLkMoIlNPPDE+IikpfX0KSC5TTy5wcm90b3R5cGU9ewpGOmZ1bmN0aW9u
+KCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLmI7cy5GKCk7KWlmKEgub1Qoci4kMShzLmdsKCkp
+KSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYS5nbCgpfX0KSC5B
+TS5wcm90b3R5cGU9ewplUjpmdW5jdGlvbihhLGIpe1AuTVIoYiwiY291bnQiLHQuUykKUC5rMShiLCJj
+b3VudCIpCnJldHVybiBuZXcgSC5BTSh0aGlzLmEsdGhpcy5iK2IsSC5MaCh0aGlzKS5DKCJBTTwxPiIp
+KX0sCmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgSC5VMShKLklUKHRoaXMuYSksdGhpcy5iLEguTGgo
+dGhpcykuQygiVTE8MT4iKSl9fQpILmQ1LnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3ZhciBzPUou
+SG0odGhpcy5hKS10aGlzLmIKaWYocz49MClyZXR1cm4gcwpyZXR1cm4gMH0sCmVSOmZ1bmN0aW9uKGEs
+Yil7UC5NUihiLCJjb3VudCIsdC5TKQpQLmsxKGIsImNvdW50IikKcmV0dXJuIG5ldyBILmQ1KHRoaXMu
+YSx0aGlzLmIrYix0aGlzLiR0aSl9LAokaWJROjF9CkguVTEucHJvdG90eXBlPXsKRjpmdW5jdGlvbigp
+e3ZhciBzLHIKZm9yKHM9dGhpcy5hLHI9MDtyPHRoaXMuYjsrK3Ipcy5GKCkKdGhpcy5iPTAKcmV0dXJu
+IHMuRigpfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmdsKCl9fQpILk1CLnByb3RvdHlwZT17
+CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBDLkd3fSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiEwfSwKZ0E6
+ZnVuY3Rpb24oYSl7cmV0dXJuIDB9LApFOmZ1bmN0aW9uKGEsYil7dGhyb3cgSC5iKFAuVEUoYiwwLDAs
+ImluZGV4IixudWxsKSl9LAplUjpmdW5jdGlvbihhLGIpe1AuazEoYiwiY291bnQiKQpyZXR1cm4gdGhp
+c319CkguRnUucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3JldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXt0
+aHJvdyBILmIoSC5XcCgpKX0sCiRpQW46MX0KSC51Ni5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXty
+ZXR1cm4gbmV3IEguSkIoSi5JVCh0aGlzLmEpLHRoaXMuJHRpLkMoIkpCPDE+IikpfX0KSC5KQi5wcm90
+b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscgpmb3Iocz10aGlzLmEscj10aGlzLiR0aS5jO3MuRigp
+OylpZihyLmIocy5nbCgpKSlyZXR1cm4hMApyZXR1cm4hMX0sCmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRo
+aXMuJHRpLmMuYSh0aGlzLmEuZ2woKSl9LAokaUFuOjF9CkguU1UucHJvdG90eXBlPXt9CkguUmUucHJv
+dG90eXBlPXsKWTU6ZnVuY3Rpb24oYSxiLGMpe0guTGgodGhpcykuQygiUmUuRSIpLmEoYykKdGhyb3cg
+SC5iKFAuTDQoIkNhbm5vdCBtb2RpZnkgYW4gdW5tb2RpZmlhYmxlIGxpc3QiKSl9fQpILncyLnByb3Rv
+dHlwZT17fQpILnd2LnByb3RvdHlwZT17CmdpTzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLl9oYXNoQ29k
+ZQppZihzIT1udWxsKXJldHVybiBzCnM9NjY0NTk3KkouaGYodGhpcy5hKSY1MzY4NzA5MTEKdGhpcy5f
+aGFzaENvZGU9cwpyZXR1cm4gc30sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuJ1N5bWJvbCgiJytILkVqKHRo
+aXMuYSkrJyIpJ30sCkROOmZ1bmN0aW9uKGEsYil7aWYoYj09bnVsbClyZXR1cm4hMQpyZXR1cm4gYiBp
+bnN0YW5jZW9mIEgud3YmJnRoaXMuYT09Yi5hfSwKJGlHRDoxfQpILlFDLnByb3RvdHlwZT17fQpILlBE
+LnByb3RvdHlwZT17fQpILldVLnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5n
+QSh0aGlzKT09PTB9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBQLm5PKHRoaXMpfSwKWTU6ZnVuY3Rpb24o
+YSxiLGMpe3ZhciBzPUguTGgodGhpcykKcy5jLmEoYikKcy5RWzFdLmEoYykKSC5kYygpCkguQmkodS5n
+KX0sCmdQdTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5xNChhLEguTGgodGhpcykuQygiTjM8MSwyPiIp
+KX0sCnE0OmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcwpyZXR1cm4gUC5sMChmdW5jdGlvbigpe3ZhciBy
+PWEKdmFyIHE9MCxwPTEsbyxuLG0sbCxrCnJldHVybiBmdW5jdGlvbiAkYXN5bmMkZ1B1KGMsZCl7aWYo
+Yz09PTEpe289ZApxPXB9d2hpbGUodHJ1ZSlzd2l0Y2gocSl7Y2FzZSAwOm49cy5ndmMoKSxuPW4uZ20o
+biksbT1ILkxoKHMpLG09bS5DKCJAPDE+IikuS3EobS5RWzFdKS5DKCJOMzwxLDI+IikKY2FzZSAyOmlm
+KCFuLkYoKSl7cT0zCmJyZWFrfWw9bi5nbCgpCms9cy5xKDAsbCkKay50b1N0cmluZwpxPTQKcmV0dXJu
+IG5ldyBQLk4zKGwsayxtKQpjYXNlIDQ6cT0yCmJyZWFrCmNhc2UgMzpyZXR1cm4gUC5UaCgpCmNhc2Ug
+MTpyZXR1cm4gUC5ZbShvKX19fSxiKX0sCiRpWjA6MX0KSC5MUC5wcm90b3R5cGU9ewpnQTpmdW5jdGlv
+bihhKXtyZXR1cm4gdGhpcy5hfSwKeDQ6ZnVuY3Rpb24oYSl7aWYodHlwZW9mIGEhPSJzdHJpbmciKXJl
+dHVybiExCmlmKCJfX3Byb3RvX18iPT09YSlyZXR1cm4hMQpyZXR1cm4gdGhpcy5iLmhhc093blByb3Bl
+cnR5KGEpfSwKcTpmdW5jdGlvbihhLGIpe2lmKCF0aGlzLng0KGIpKXJldHVybiBudWxsCnJldHVybiB0
+aGlzLnFQKGIpfSwKcVA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYltILmgoYSldfSwKSzpmdW5jdGlv
+bihhLGIpe3ZhciBzLHIscSxwLG89SC5MaCh0aGlzKQpvLkMoIn4oMSwyKSIpLmEoYikKcz10aGlzLmMK
+Zm9yKHI9cy5sZW5ndGgsbz1vLlFbMV0scT0wO3E8cjsrK3Epe3A9c1txXQpiLiQyKHAsby5hKHRoaXMu
+cVAocCkpKX19LApndmM6ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEguWFIodGhpcyxILkxoKHRoaXMpLkMo
+IlhSPDE+IikpfX0KSC5YUi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEuYwpy
+ZXR1cm4gbmV3IEoubTEocyxzLmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfSwKZ0E6ZnVuY3Rpb24o
+YSl7cmV0dXJuIHRoaXMuYS5jLmxlbmd0aH19CkguTEkucHJvdG90eXBlPXsKZ1dhOmZ1bmN0aW9uKCl7
+dmFyIHM9dGhpcy5hCnJldHVybiBzfSwKZ25kOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlm
+KG8uYz09PTEpcmV0dXJuIEMuaFUKcz1vLmQKcj1zLmxlbmd0aC1vLmUubGVuZ3RoLW8uZgppZihyPT09
+MClyZXR1cm4gQy5oVQpxPVtdCmZvcihwPTA7cDxyOysrcCl7aWYocD49cy5sZW5ndGgpcmV0dXJuIEgu
+T0gocyxwKQpxLnB1c2goc1twXSl9cmV0dXJuIEouekMocSl9LApnVm06ZnVuY3Rpb24oKXt2YXIgcyxy
+LHEscCxvLG4sbSxsLGs9dGhpcwppZihrLmMhPT0wKXJldHVybiBDLldPCnM9ay5lCnI9cy5sZW5ndGgK
+cT1rLmQKcD1xLmxlbmd0aC1yLWsuZgppZihyPT09MClyZXR1cm4gQy5XTwpvPW5ldyBILk41KHQuZW8p
+CmZvcihuPTA7bjxyOysrbil7aWYobj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxuKQptPXNbbl0KbD1w
+K24KaWYobDwwfHxsPj1xLmxlbmd0aClyZXR1cm4gSC5PSChxLGwpCm8uWTUoMCxuZXcgSC53dihtKSxx
+W2xdKX1yZXR1cm4gbmV3IEguUEQobyx0LmdGKX0sCiRpdlE6MX0KSC5Dai5wcm90b3R5cGU9ewokMjpm
+dW5jdGlvbihhLGIpe3ZhciBzCkguaChhKQpzPXRoaXMuYQpzLmI9cy5iKyIkIitILkVqKGEpCkMuTm0u
+aSh0aGlzLmIsYSkKQy5ObS5pKHRoaXMuYyxiKTsrK3MuYX0sCiRTOjEyfQpILmY5LnByb3RvdHlwZT17
+CnFTOmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9bmV3IFJlZ0V4cChxLmEpLmV4ZWMoYSkKaWYo
+cD09bnVsbClyZXR1cm4gbnVsbApzPU9iamVjdC5jcmVhdGUobnVsbCkKcj1xLmIKaWYociE9PS0xKXMu
+YXJndW1lbnRzPXBbcisxXQpyPXEuYwppZihyIT09LTEpcy5hcmd1bWVudHNFeHByPXBbcisxXQpyPXEu
+ZAppZihyIT09LTEpcy5leHByPXBbcisxXQpyPXEuZQppZihyIT09LTEpcy5tZXRob2Q9cFtyKzFdCnI9
+cS5mCmlmKHIhPT0tMSlzLnJlY2VpdmVyPXBbcisxXQpyZXR1cm4gc319CkguVzAucHJvdG90eXBlPXsK
+dzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIKaWYocz09bnVsbClyZXR1cm4iTm9TdWNoTWV0aG9kRXJy
+b3I6ICIrSC5Faih0aGlzLmEpCnJldHVybiJOb1N1Y2hNZXRob2RFcnJvcjogbWV0aG9kIG5vdCBmb3Vu
+ZDogJyIrcysiJyBvbiBudWxsIn19CkguYXoucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxy
+PXRoaXMscT0iTm9TdWNoTWV0aG9kRXJyb3I6IG1ldGhvZCBub3QgZm91bmQ6ICciLHA9ci5iCmlmKHA9
+PW51bGwpcmV0dXJuIk5vU3VjaE1ldGhvZEVycm9yOiAiK0guRWooci5hKQpzPXIuYwppZihzPT1udWxs
+KXJldHVybiBxK3ArIicgKCIrSC5FaihyLmEpKyIpIgpyZXR1cm4gcStwKyInIG9uICciK3MrIicgKCIr
+SC5FaihyLmEpKyIpIn19CkgudlYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEK
+cmV0dXJuIHMubGVuZ3RoPT09MD8iRXJyb3IiOiJFcnJvcjogIitzfX0KSC50ZS5wcm90b3R5cGU9ewp3
+OmZ1bmN0aW9uKGEpe3JldHVybiJUaHJvdyBvZiBudWxsICgnIisodGhpcy5hPT09bnVsbD8ibnVsbCI6
+InVuZGVmaW5lZCIpKyInIGZyb20gSmF2YVNjcmlwdCkifSwKJGlSejoxfQpILmJxLnByb3RvdHlwZT17
+fQpILlhPLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLmIKaWYociE9bnVsbCly
+ZXR1cm4gcgpyPXRoaXMuYQpzPXIhPT1udWxsJiZ0eXBlb2Ygcj09PSJvYmplY3QiP3Iuc3RhY2s6bnVs
+bApyZXR1cm4gdGhpcy5iPXM9PW51bGw/IiI6c30sCiRpR3o6MX0KSC5UcC5wcm90b3R5cGU9ewp3OmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuY29uc3RydWN0b3Iscj1zPT1udWxsP251bGw6cy5uYW1lCnJldHVy
+biJDbG9zdXJlICciK0guTlEocj09bnVsbD8idW5rbm93biI6cikrIicifSwKJGlFSDoxLApnS3U6ZnVu
+Y3Rpb24oKXtyZXR1cm4gdGhpc30sCiRDOiIkMSIsCiRSOjEsCiREOm51bGx9CkgubGMucHJvdG90eXBl
+PXt9CkguengucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLiRzdGF0aWNfbmFtZQpp
+ZihzPT1udWxsKXJldHVybiJDbG9zdXJlIG9mIHVua25vd24gc3RhdGljIG1ldGhvZCIKcmV0dXJuIkNs
+b3N1cmUgJyIrSC5OUShzKSsiJyJ9fQpILnJULnByb3RvdHlwZT17CkROOmZ1bmN0aW9uKGEsYil7dmFy
+IHM9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHM9PT1iKXJldHVybiEwCmlmKCEoYiBpbnN0YW5j
+ZW9mIEguclQpKXJldHVybiExCnJldHVybiBzLmE9PT1iLmEmJnMuYj09PWIuYiYmcy5jPT09Yi5jfSwK
+Z2lPOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5jCmlmKHI9PW51bGwpcz1ILmVRKHRoaXMuYSkKZWxz
+ZSBzPXR5cGVvZiByIT09Im9iamVjdCI/Si5oZihyKTpILmVRKHIpCnI9SC5lUSh0aGlzLmIpCmlmKHR5
+cGVvZiBzIT09Im51bWJlciIpcmV0dXJuIHMuWSgpCnJldHVybihzXnIpPj4+MH0sCnc6ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcy5jCmlmKHM9PW51bGwpcz10aGlzLmEKcmV0dXJuIkNsb3N1cmUgJyIrSC5Faih0
+aGlzLmQpKyInIG9mICIrKCJJbnN0YW5jZSBvZiAnIitILkVqKEguTShzKSkrIiciKX19CkguRXEucHJv
+dG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iUnVudGltZUVycm9yOiAiK3RoaXMuYX19Ckgua1ku
+cHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iQXNzZXJ0aW9uIGZhaWxlZDogIitQLnAodGhp
+cy5hKX19Ckgua3IucHJvdG90eXBlPXt9CkguTjUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0
+dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09MH0sCmd2YzpmdW5jdGlv
+bigpe3JldHVybiBuZXcgSC5pNSh0aGlzLEguTGgodGhpcykuQygiaTU8MT4iKSl9LAp4NDpmdW5jdGlv
+bihhKXt2YXIgcyxyCmlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz10aGlzLmIKaWYocz09bnVsbClyZXR1
+cm4hMQpyZXR1cm4gdGhpcy5YdShzLGEpfWVsc2V7cj10aGlzLkNYKGEpCnJldHVybiByfX0sCkNYOmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuZAppZihzPT1udWxsKXJldHVybiExCnJldHVybiB0aGlzLkZoKHRo
+aXMuQnQocyxKLmhmKGEpJjB4M2ZmZmZmZiksYSk+PTB9LApxOmZ1bmN0aW9uKGEsYil7dmFyIHMscixx
+LHAsbz10aGlzLG49bnVsbAppZih0eXBlb2YgYj09InN0cmluZyIpe3M9by5iCmlmKHM9PW51bGwpcmV0
+dXJuIG4Kcj1vLmoyKHMsYikKcT1yPT1udWxsP246ci5iCnJldHVybiBxfWVsc2UgaWYodHlwZW9mIGI9
+PSJudW1iZXIiJiYoYiYweDNmZmZmZmYpPT09Yil7cD1vLmMKaWYocD09bnVsbClyZXR1cm4gbgpyPW8u
+ajIocCxiKQpxPXI9PW51bGw/bjpyLmIKcmV0dXJuIHF9ZWxzZSByZXR1cm4gby5hYShiKX0sCmFhOmZ1
+bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLmQKaWYocT09bnVsbClyZXR1cm4gbnVsbApzPXRoaXMuQnQo
+cSxKLmhmKGEpJjB4M2ZmZmZmZikKcj10aGlzLkZoKHMsYSkKaWYocjwwKXJldHVybiBudWxsCnJldHVy
+biBzW3JdLmJ9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPUguTGgo
+bSkKbC5jLmEoYikKbC5RWzFdLmEoYykKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtzPW0uYgptLkVIKHM9
+PW51bGw/bS5iPW0ueksoKTpzLGIsYyl9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJlciImJihiJjB4M2Zm
+ZmZmZik9PT1iKXtyPW0uYwptLkVIKHI9PW51bGw/bS5jPW0ueksoKTpyLGIsYyl9ZWxzZXtxPW0uZApp
+ZihxPT1udWxsKXE9bS5kPW0ueksoKQpwPUouaGYoYikmMHgzZmZmZmZmCm89bS5CdChxLHApCmlmKG89
+PW51bGwpbS5FSShxLHAsW20uSG4oYixjKV0pCmVsc2V7bj1tLkZoKG8sYikKaWYobj49MClvW25dLmI9
+YwplbHNlIG8ucHVzaChtLkhuKGIsYykpfX19LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMK
+SC5MaChxKS5DKCJ+KDEsMikiKS5hKGIpCnM9cS5lCnI9cS5yCmZvcig7cyE9bnVsbDspe2IuJDIocy5h
+LHMuYikKaWYociE9PXEucil0aHJvdyBILmIoUC5hNChxKSkKcz1zLmN9fSwKRUg6ZnVuY3Rpb24oYSxi
+LGMpe3ZhciBzLHI9dGhpcyxxPUguTGgocikKcS5jLmEoYikKcS5RWzFdLmEoYykKcz1yLmoyKGEsYikK
+aWYocz09bnVsbClyLkVJKGEsYixyLkhuKGIsYykpCmVsc2Ugcy5iPWN9LAprczpmdW5jdGlvbigpe3Ro
+aXMucj10aGlzLnIrMSY2NzEwODg2M30sCkhuOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcyxyPUguTGgo
+cykscT1uZXcgSC52aChyLmMuYShhKSxyLlFbMV0uYShiKSkKaWYocy5lPT1udWxsKXMuZT1zLmY9cQpl
+bHNle3I9cy5mCnIudG9TdHJpbmcKcS5kPXIKcy5mPXIuYz1xfSsrcy5hCnMua3MoKQpyZXR1cm4gcX0s
+CkZoOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZihhPT1udWxsKXJldHVybi0xCnM9YS5sZW5ndGgKZm9y
+KHI9MDtyPHM7KytyKWlmKEouUk0oYVtyXS5hLGIpKXJldHVybiByCnJldHVybi0xfSwKdzpmdW5jdGlv
+bihhKXtyZXR1cm4gUC5uTyh0aGlzKX0sCmoyOmZ1bmN0aW9uKGEsYil7cmV0dXJuIGFbYl19LApCdDpm
+dW5jdGlvbihhLGIpe3JldHVybiBhW2JdfSwKRUk6ZnVuY3Rpb24oYSxiLGMpe2FbYl09Y30sCnJuOmZ1
+bmN0aW9uKGEsYil7ZGVsZXRlIGFbYl19LApYdTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmoyKGEs
+YikhPW51bGx9LAp6SzpmdW5jdGlvbigpe3ZhciBzPSI8bm9uLWlkZW50aWZpZXIta2V5PiIscj1PYmpl
+Y3QuY3JlYXRlKG51bGwpCnRoaXMuRUkocixzLHIpCnRoaXMucm4ocixzKQpyZXR1cm4gcn0sCiRpRm86
+MX0KSC52aC5wcm90b3R5cGU9e30KSC5pNS5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy5hLmF9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5hPT09MH0sCmdtOmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMuYSxyPW5ldyBILk42KHMscy5yLHRoaXMuJHRpLkMoIk42PDE+IikpCnIuYz1z
+LmUKcmV0dXJuIHJ9LAp0ZzpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEueDQoYil9fQpILk42LnBy
+b3RvdHlwZT17CmdsOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZH0sCkY6ZnVuY3Rpb24oKXt2YXIgcyxy
+PXRoaXMscT1yLmEKaWYoci5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQpzPXIuYwppZihzPT1udWxs
+KXtyLnNxWShudWxsKQpyZXR1cm4hMX1lbHNle3Iuc3FZKHMuYSkKci5jPXMuYwpyZXR1cm4hMH19LApz
+cVk6ZnVuY3Rpb24oYSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KSC5kQy5w
+cm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hKGEpfSwKJFM6NH0KSC53Ti5wcm90
+b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzLmEoYSxiKX0sCiRTOjQ2fQpILlZYLnBy
+b3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEoSC5oKGEpKX0sCiRTOjQxfQpILlZS
+LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIlJlZ0V4cC8iK3RoaXMuYSsiLyIrdGhpcy5i
+LmZsYWdzfSwKZ0hjOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcyxyPXMuYwppZihyIT1udWxsKXJldHVybiBy
+CnI9cy5iCnJldHVybiBzLmM9SC52NChzLmEsci5tdWx0aWxpbmUsIXIuaWdub3JlQ2FzZSxyLnVuaWNv
+ZGUsci5kb3RBbGwsITApfSwKZGQ6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gbmV3IEguS1codGhpcyxiLDAp
+fSwKVVo6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuZ0hjKCkKci5sYXN0SW5kZXg9YgpzPXIuZXhl
+YyhhKQppZihzPT1udWxsKXJldHVybiBudWxsCnJldHVybiBuZXcgSC5FSyhzKX0sCiRpdlg6MSwKJGl3
+TDoxfQpILkVLLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIpCnM9dGhpcy5i
+CmlmKGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcmV0dXJuIHNbYl19LAokaU9kOjEsCiRpaWI6
+MX0KSC5LVy5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguUGIodGhpcy5hLHRo
+aXMuYix0aGlzLmMpfX0KSC5QYi5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9
+LApGOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPW0uYgppZihsPT1udWxsKXJldHVy
+biExCnM9bS5jCnI9bC5sZW5ndGgKaWYoczw9cil7cT1tLmEKcD1xLlVaKGwscykKaWYocCE9bnVsbCl7
+bS5kPXAKcz1wLmIKbz1zLmluZGV4Cm49bytzWzBdLmxlbmd0aAppZihvPT09bil7aWYocS5iLnVuaWNv
+ZGUpe3M9bS5jCnE9cysxCmlmKHE8cil7cz1DLnhCLk8yKGwscykKaWYocz49NTUyOTYmJnM8PTU2MzE5
+KXtzPUMueEIuTzIobCxxKQpzPXM+PTU2MzIwJiZzPD01NzM0M31lbHNlIHM9ITF9ZWxzZSBzPSExfWVs
+c2Ugcz0hMQpuPShzP24rMTpuKSsxfW0uYz1uCnJldHVybiEwfX1tLmI9bS5kPW51bGwKcmV0dXJuITF9
+LAokaUFuOjF9CkgudFEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKaWYoYiE9PTAp
+SC52KFAuTzcoYixudWxsKSkKcmV0dXJuIHRoaXMuY30sCiRpT2Q6MX0KSC51bi5wcm90b3R5cGU9ewpn
+bTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEguU2QodGhpcy5hLHRoaXMuYix0aGlzLmMpfX0KSC5TZC5w
+cm90b3R5cGU9ewpGOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMscD1xLmMsbz1xLmIsbj1vLmxlbmd0
+aCxtPXEuYSxsPW0ubGVuZ3RoCmlmKHArbj5sKXtxLmQ9bnVsbApyZXR1cm4hMX1zPW0uaW5kZXhPZihv
+LHApCmlmKHM8MCl7cS5jPWwrMQpxLmQ9bnVsbApyZXR1cm4hMX1yPXMrbgpxLmQ9bmV3IEgudFEocyxv
+KQpxLmM9cj09PXEuYz9yKzE6cgpyZXR1cm4hMH0sCmdsOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5kCnMu
+dG9TdHJpbmcKcmV0dXJuIHN9LAokaUFuOjF9CkguRVQucHJvdG90eXBlPXskaUVUOjEsJGlBUzoxfQpI
+LkxaLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0sCiRpWGo6MX0KSC5E
+Zy5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0
+dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIsYyl7SC5HSChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVti
+XT1jfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0KSC5QZy5wcm90b3R5cGU9ewpZNTpmdW5jdGlvbihh
+LGIsYyl7SC51UChjKQpILm9kKGIsYSxhLmxlbmd0aCkKYVtiXT1jfSwKJGliUToxLAokaWNYOjEsCiRp
+ek06MX0KSC54ai5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxl
+bmd0aCkKcmV0dXJuIGFbYl19fQpILmRFLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIp
+Ckgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVtiXX19CkguWkEucHJvdG90eXBlPXsKcTpmdW5jdGlv
+bihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kVC5wcm90b3R5
 cGU9ewpxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19
-fQpILmRFLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3Ro
-KQpyZXR1cm4gYVtiXX19CkguWkEucHJvdG90eXBlPXsKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5v
-ZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5kVC5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEs
-Yil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19fQpILlBxLnByb3RvdHlwZT17
-CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3RoKQpyZXR1cm4gYVtiXX19Ckgu
-ZUUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofSwKcTpmdW5jdGlvbihh
-LGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2JdfX0KSC5WNi5wcm90b3R5cGU9
-ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpI
-Lm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LAokaVY2OjEsCiRpbjY6MX0KSC5SRy5wcm90b3R5
-cGU9e30KSC5WUC5wcm90b3R5cGU9e30KSC5XQi5wcm90b3R5cGU9e30KSC5aRy5wcm90b3R5cGU9e30K
-SC5KYy5wcm90b3R5cGU9ewpDOmZ1bmN0aW9uKGEpe3JldHVybiBILmNFKHYudHlwZVVuaXZlcnNlLHRo
-aXMsYSl9LApLcTpmdW5jdGlvbihhKXtyZXR1cm4gSC52NSh2LnR5cGVVbml2ZXJzZSx0aGlzLGEpfX0K
-SC5HLnByb3RvdHlwZT17fQpILmxZLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIEguZG0o
-dGhpcy5hLG51bGwpfX0KSC5rUy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9
-fQpILmlNLnByb3RvdHlwZT17fQpQLnRoLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRo
-aXMuYSxyPXMuYQpzLmE9bnVsbApyLiQwKCl9LAokUzo5fQpQLmhhLnByb3RvdHlwZT17CiQxOmZ1bmN0
-aW9uKGEpe3ZhciBzLHIKdGhpcy5hLmE9dC5NLmEoYSkKcz10aGlzLmIKcj10aGlzLmMKcy5maXJzdENo
-aWxkP3MucmVtb3ZlQ2hpbGQocik6cy5hcHBlbmRDaGlsZChyKX0sCiRTOjM0fQpQLlZzLnByb3RvdHlw
-ZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLiQwKCl9LAokQzoiJDAiLAokUjowLAokUzoyfQpQLkZ0LnBy
-b3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLiQwKCl9LAokQzoiJDAiLAokUjowLAokUzoyfQpQ
-LlczLnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYil7aWYoc2VsZi5zZXRUaW1lb3V0IT1udWxsKXNl
-bGYuc2V0VGltZW91dChILnRSKG5ldyBQLnlIKHRoaXMsYiksMCksYSkKZWxzZSB0aHJvdyBILmIoUC5M
-NCgiYHNldFRpbWVvdXQoKWAgbm90IGZvdW5kLiIpKX19ClAueUgucHJvdG90eXBlPXsKJDA6ZnVuY3Rp
-b24oKXt0aGlzLmIuJDAoKX0sCiRDOiIkMCIsCiRSOjAsCiRTOjB9ClAuaWgucHJvdG90eXBlPXsKYU06
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMscT1yLiR0aQpxLkMoIjEvPyIpLmEoYikKaWYoIXIuYily
-LmEuWGYoYikKZWxzZXtzPXIuYQppZihxLkMoImI4PDE+IikuYihiKSlzLmNVKGIpCmVsc2Ugcy5YMihx
-LmMuYShiKSl9fSwKdzA6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihiPT1udWxsKWI9UC52MChhKQpzPXRo
-aXMuYQppZih0aGlzLmIpcy5aTChhLGIpCmVsc2Ugcy5OayhhLGIpfX0KUC5XTS5wcm90b3R5cGU9ewok
-MTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLiQyKDAsYSl9LAokUzo1Mn0KUC5TWC5wcm90b3R5cGU9
-ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS4kMigxLG5ldyBILmJxKGEsdC5sLmEoYikpKX0sCiRDOiIk
-MiIsCiRSOjIsCiRTOjI0fQpQLkdzLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5hKEgu
-dVAoYSksYil9LAokUzoyNn0KUC5GeS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJJdGVy
-YXRpb25NYXJrZXIoIit0aGlzLmIrIiwgIitILkVqKHRoaXMuYSkrIikifX0KUC5HVi5wcm90b3R5cGU9
-ewpnbDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYwppZihzPT1udWxsKXJldHVybiB0aGlzLiR0aS5jLmEo
-dGhpcy5iKQpyZXR1cm4gcy5nbCgpfSwKRjpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMK
-Zm9yKHM9bS4kdGkuQygiQW48MT4iKTshMDspe3I9bS5jCmlmKHIhPW51bGwpaWYoci5GKCkpcmV0dXJu
-ITAKZWxzZSBtLnNYOShudWxsKQpxPWZ1bmN0aW9uKGEsYixjKXt2YXIgbCxrPWIKd2hpbGUodHJ1ZSl0
-cnl7cmV0dXJuIGEoayxsKX1jYXRjaChqKXtsPWoKaz1jfX0obS5hLDAsMSkKaWYocSBpbnN0YW5jZW9m
-IFAuRnkpe3A9cS5iCmlmKHA9PT0yKXtvPW0uZAppZihvPT1udWxsfHxvLmxlbmd0aD09PTApe20uc0VD
-KG51bGwpCnJldHVybiExfWlmKDA+PW8ubGVuZ3RoKXJldHVybiBILk9IKG8sLTEpCm0uYT1vLnBvcCgp
-CmNvbnRpbnVlfWVsc2V7cj1xLmEKaWYocD09PTMpdGhyb3cgcgplbHNle249cy5hKEouSVQocikpCmlm
-KG4gaW5zdGFuY2VvZiBQLkdWKXtyPW0uZAppZihyPT1udWxsKXI9bS5kPVtdCkMuTm0uaShyLG0uYSkK
-bS5hPW4uYQpjb250aW51ZX1lbHNle20uc1g5KG4pCmNvbnRpbnVlfX19fWVsc2V7bS5zRUMocSkKcmV0
-dXJuITB9fXJldHVybiExfSwKc0VDOmZ1bmN0aW9uKGEpe3RoaXMuYj10aGlzLiR0aS5DKCIxPyIpLmEo
-YSl9LApzWDk6ZnVuY3Rpb24oYSl7dGhpcy5jPXRoaXMuJHRpLkMoIkFuPDE+PyIpLmEoYSl9LAokaUFu
-OjF9ClAucTQucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBQLkdWKHRoaXMuYSgp
-LHRoaXMuJHRpLkMoIkdWPDE+IikpfX0KUC5QZi5wcm90b3R5cGU9ewp3MDpmdW5jdGlvbihhLGIpe3Zh
-ciBzCkguY2IoYSwiZXJyb3IiLHQuSykKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBILmIoUC5QVigi
-RnV0dXJlIGFscmVhZHkgY29tcGxldGVkIikpCmlmKGI9PW51bGwpYj1QLnYwKGEpCnMuTmsoYSxiKX0s
-CnBtOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLncwKGEsbnVsbCl9fQpQLlpmLnByb3RvdHlwZT17CmFN
-OmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLiR0aQpyLkMoIjEvPyIpLmEoYikKcz10aGlzLmEKaWYo
-cy5hIT09MCl0aHJvdyBILmIoUC5QVigiRnV0dXJlIGFscmVhZHkgY29tcGxldGVkIikpCnMuWGYoci5D
-KCIxLyIpLmEoYikpfX0KUC5GZS5wcm90b3R5cGU9ewpIUjpmdW5jdGlvbihhKXtpZigodGhpcy5jJjE1
-KSE9PTYpcmV0dXJuITAKcmV0dXJuIHRoaXMuYi5iLmJ2KHQuYWwuYSh0aGlzLmQpLGEuYSx0LnksdC5L
-KX0sCkt3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZSxyPXQueixxPXQuSyxwPXRoaXMuJHRpLkMoIjIv
-Iiksbz10aGlzLmIuYgppZih0LmFnLmIocykpcmV0dXJuIHAuYShvLnJwKHMsYS5hLGEuYixyLHEsdC5s
-KSkKZWxzZSByZXR1cm4gcC5hKG8uYnYodC5iSS5hKHMpLGEuYSxyLHEpKX19ClAudnMucHJvdG90eXBl
-PXsKU3E6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwPXRoaXMuJHRpCnAuS3EoYykuQygiMS8oMiki
-KS5hKGEpCnM9JC5YMwppZihzIT09Qy5OVSl7Yy5DKCJAPDAvPiIpLktxKHAuYykuQygiMSgyKSIpLmEo
-YSkKaWYoYiE9bnVsbCliPVAuVkgoYixzKX1yPW5ldyBQLnZzKHMsYy5DKCJ2czwwPiIpKQpxPWI9PW51
-bGw/MTozCnRoaXMueGYobmV3IFAuRmUocixxLGEsYixwLkMoIkA8MT4iKS5LcShjKS5DKCJGZTwxLDI+
-IikpKQpyZXR1cm4gcn0sClc3OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuU3EoYSxudWxsLGIpfSwK
-UWQ6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9dGhpcy4kdGkKci5LcShjKS5DKCIxLygyKSIpLmEoYSkK
-cz1uZXcgUC52cygkLlgzLGMuQygidnM8MD4iKSkKdGhpcy54ZihuZXcgUC5GZShzLDE5LGEsYixyLkMo
-IkA8MT4iKS5LcShjKS5DKCJGZTwxLDI+IikpKQpyZXR1cm4gc30sCnhmOmZ1bmN0aW9uKGEpe3ZhciBz
-LHI9dGhpcyxxPXIuYQppZihxPD0xKXthLmE9dC5GLmEoci5jKQpyLmM9YX1lbHNle2lmKHE9PT0yKXtz
-PXQuYy5hKHIuYykKcT1zLmEKaWYocTw0KXtzLnhmKGEpCnJldHVybn1yLmE9cQpyLmM9cy5jfVAuVGso
-bnVsbCxudWxsLHIuYix0Lk0uYShuZXcgUC5kYShyLGEpKSl9fSwKalE6ZnVuY3Rpb24oYSl7dmFyIHMs
-cixxLHAsbyxuLG09dGhpcyxsPXt9CmwuYT1hCmlmKGE9PW51bGwpcmV0dXJuCnM9bS5hCmlmKHM8PTEp
-e3I9dC5GLmEobS5jKQptLmM9YQppZihyIT1udWxsKXtxPWEuYQpmb3IocD1hO3EhPW51bGw7cD1xLHE9
-bylvPXEuYQpwLmE9cn19ZWxzZXtpZihzPT09Mil7bj10LmMuYShtLmMpCnM9bi5hCmlmKHM8NCl7bi5q
-UShhKQpyZXR1cm59bS5hPXMKbS5jPW4uY31sLmE9bS5OOChhKQpQLlRrKG51bGwsbnVsbCxtLmIsdC5N
-LmEobmV3IFAub1EobCxtKSkpfX0sCmFoOmZ1bmN0aW9uKCl7dmFyIHM9dC5GLmEodGhpcy5jKQp0aGlz
-LmM9bnVsbApyZXR1cm4gdGhpcy5OOChzKX0sCk44OmZ1bmN0aW9uKGEpe3ZhciBzLHIscQpmb3Iocz1h
-LHI9bnVsbDtzIT1udWxsO3I9cyxzPXEpe3E9cy5hCnMuYT1yfXJldHVybiByfSwKSEg6ZnVuY3Rpb24o
-YSl7dmFyIHMscj10aGlzLHE9ci4kdGkKcS5DKCIxLyIpLmEoYSkKaWYocS5DKCJiODwxPiIpLmIoYSkp
-aWYocS5iKGEpKVAuQTkoYSxyKQplbHNlIFAuazMoYSxyKQplbHNle3M9ci5haCgpCnEuYy5hKGEpCnIu
-YT00CnIuYz1hClAuSFoocixzKX19LApYMjpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMKci4kdGkuYy5h
-KGEpCnM9ci5haCgpCnIuYT00CnIuYz1hClAuSFoocixzKX0sClpMOmZ1bmN0aW9uKGEsYil7dmFyIHMs
-cixxPXRoaXMKdC5sLmEoYikKcz1xLmFoKCkKcj1QLlRsKGEsYikKcS5hPTgKcS5jPXIKUC5IWihxLHMp
-fSwKWGY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy4kdGkKcy5DKCIxLyIpLmEoYSkKaWYocy5DKCJiODwx
-PiIpLmIoYSkpe3RoaXMuY1UoYSkKcmV0dXJufXRoaXMud1Uocy5jLmEoYSkpfSwKd1U6ZnVuY3Rpb24o
-YSl7dmFyIHM9dGhpcwpzLiR0aS5jLmEoYSkKcy5hPTEKUC5UayhudWxsLG51bGwscy5iLHQuTS5hKG5l
-dyBQLnJ0KHMsYSkpKX0sCmNVOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMscj1zLiR0aQpyLkMoImI4PDE+
-IikuYShhKQppZihyLmIoYSkpe2lmKGEuYT09PTgpe3MuYT0xClAuVGsobnVsbCxudWxsLHMuYix0Lk0u
-YShuZXcgUC5LRihzLGEpKSl9ZWxzZSBQLkE5KGEscykKcmV0dXJufVAuazMoYSxzKX0sCk5rOmZ1bmN0
-aW9uKGEsYil7dGhpcy5hPTEKUC5UayhudWxsLG51bGwsdGhpcy5iLHQuTS5hKG5ldyBQLlpMKHRoaXMs
-YSxiKSkpfSwKJGliODoxfQpQLmRhLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7UC5IWih0aGlzLmEs
-dGhpcy5iKX0sCiRTOjB9ClAub1EucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtQLkhaKHRoaXMuYix0
-aGlzLmEuYSl9LAokUzowfQpQLnBWLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
-YQpzLmE9MApzLkhIKGEpfSwKJFM6OX0KUC5VNy5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3Ro
-aXMuYS5aTChhLHQubC5hKGIpKX0sCiRDOiIkMiIsCiRSOjIsCiRTOjI5fQpQLnZyLnByb3RvdHlwZT17
-CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRoaXMuYix0aGlzLmMpfSwKJFM6MH0KUC5ydC5wcm90b3R5
-cGU9ewokMDpmdW5jdGlvbigpe3RoaXMuYS5YMih0aGlzLmIpfSwKJFM6MH0KUC5LRi5wcm90b3R5cGU9
-ewokMDpmdW5jdGlvbigpe1AuQTkodGhpcy5iLHRoaXMuYSl9LAokUzowfQpQLlpMLnByb3RvdHlwZT17
-CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLlpMKHRoaXMuYix0aGlzLmMpfSwKJFM6MH0KUC5SVC5wcm90b3R5
-cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMsbD1udWxsCnRyeXtxPW0uYS5h
-Cmw9cS5iLmIuenoodC5mTy5hKHEuZCksdC56KX1jYXRjaChwKXtzPUguUnUocCkKcj1ILnRzKHApCmlm
-KG0uYyl7cT10Lm4uYShtLmIuYS5jKS5hCm89cwpvPXE9PW51bGw/bz09bnVsbDpxPT09bwpxPW99ZWxz
-ZSBxPSExCm89bS5hCmlmKHEpby5jPXQubi5hKG0uYi5hLmMpCmVsc2Ugby5jPVAuVGwocyxyKQpvLmI9
-ITAKcmV0dXJufWlmKGwgaW5zdGFuY2VvZiBQLnZzJiZsLmE+PTQpe2lmKGwuYT09PTgpe3E9bS5hCnEu
-Yz10Lm4uYShsLmMpCnEuYj0hMH1yZXR1cm59aWYodC5kLmIobCkpe249bS5iLmEKcT1tLmEKcS5jPWwu
-VzcobmV3IFAualoobiksdC56KQpxLmI9ITF9fSwKJFM6MH0KUC5qWi5wcm90b3R5cGU9ewokMTpmdW5j
-dGlvbihhKXtyZXR1cm4gdGhpcy5hfSwKJFM6MzJ9ClAucnEucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24o
-KXt2YXIgcyxyLHEscCxvLG4sbSxsCnRyeXtxPXRoaXMuYQpwPXEuYQpvPXAuJHRpCm49by5jCm09bi5h
-KHRoaXMuYikKcS5jPXAuYi5iLmJ2KG8uQygiMi8oMSkiKS5hKHAuZCksbSxvLkMoIjIvIiksbil9Y2F0
-Y2gobCl7cz1ILlJ1KGwpCnI9SC50cyhsKQpxPXRoaXMuYQpxLmM9UC5UbChzLHIpCnEuYj0hMH19LAok
-UzowfQpQLlJXLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxuLG0sbCxrPXRo
-aXMKdHJ5e3M9dC5uLmEoay5hLmEuYykKcD1rLmIKaWYoSC5vVChwLmEuSFIocykpJiZwLmEuZSE9bnVs
-bCl7cC5jPXAuYS5LdyhzKQpwLmI9ITF9fWNhdGNoKG8pe3I9SC5SdShvKQpxPUgudHMobykKcD10Lm4u
-YShrLmEuYS5jKQpuPXAuYQptPXIKbD1rLmIKaWYobj09bnVsbD9tPT1udWxsOm49PT1tKWwuYz1wCmVs
-c2UgbC5jPVAuVGwocixxKQpsLmI9ITB9fSwKJFM6MH0KUC5PTS5wcm90b3R5cGU9e30KUC5xaC5wcm90
-b3R5cGU9ewpnQTpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxwPXt9LG89bmV3IFAudnMoJC5YMyx0
-LmZKKQpwLmE9MApzPUguTGgocSkKcj1zLkMoIn4oMSk/IikuYShuZXcgUC5CNShwLHEpKQp0LlouYShu
-ZXcgUC51TyhwLG8pKQpXLkpFKHEuYSxxLmIsciwhMSxzLmMpCnJldHVybiBvfX0KUC5CNS5wcm90b3R5
-cGU9ewokMTpmdW5jdGlvbihhKXtILkxoKHRoaXMuYikuYy5hKGEpOysrdGhpcy5hLmF9LAokUzpmdW5j
-dGlvbigpe3JldHVybiBILkxoKHRoaXMuYikuQygifigxKSIpfX0KUC51Ty5wcm90b3R5cGU9ewokMDpm
-dW5jdGlvbigpe3RoaXMuYi5ISCh0aGlzLmEuYSl9LAokUzowfQpQLk1PLnByb3RvdHlwZT17fQpQLmtU
-LnByb3RvdHlwZT17fQpQLnhJLnByb3RvdHlwZT17fQpQLkN3LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24o
-YSl7cmV0dXJuIEguRWoodGhpcy5hKX0sCiRpWFM6MSwKZ0lJOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMu
-Yn19ClAubTAucHJvdG90eXBlPXskaVFtOjF9ClAucEsucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2
-YXIgcz1ILmIodGhpcy5hKQpzLnN0YWNrPUouaih0aGlzLmIpCnRocm93IHN9LAokUzowfQpQLkppLnBy
-b3RvdHlwZT17CmJIOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPW51bGwKdC5NLmEoYSkKdHJ5e2lmKEMu
-TlU9PT0kLlgzKXthLiQwKCkKcmV0dXJufVAuVDgocCxwLHRoaXMsYSx0LkgpfWNhdGNoKHEpe3M9SC5S
-dShxKQpyPUgudHMocSkKUC5MMihwLHAsdGhpcyxzLHQubC5hKHIpKX19LApEbDpmdW5jdGlvbihhLGIs
-Yyl7dmFyIHMscixxLHA9bnVsbApjLkMoIn4oMCkiKS5hKGEpCmMuYShiKQp0cnl7aWYoQy5OVT09PSQu
-WDMpe2EuJDEoYikKcmV0dXJufVAueXYocCxwLHRoaXMsYSxiLHQuSCxjKX1jYXRjaChxKXtzPUguUnUo
-cSkKcj1ILnRzKHEpClAuTDIocCxwLHRoaXMscyx0LmwuYShyKSl9fSwKUlQ6ZnVuY3Rpb24oYSxiKXty
-ZXR1cm4gbmV3IFAuaGoodGhpcyxiLkMoIjAoKSIpLmEoYSksYil9LAp0ODpmdW5jdGlvbihhKXtyZXR1
-cm4gbmV3IFAuVnAodGhpcyx0Lk0uYShhKSl9LApQeTpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC5P
-Uih0aGlzLGIuQygifigwKSIpLmEoYSksYil9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51bGx9LAp6
-ejpmdW5jdGlvbihhLGIpe2IuQygiMCgpIikuYShhKQppZigkLlgzPT09Qy5OVSlyZXR1cm4gYS4kMCgp
-CnJldHVybiBQLlQ4KG51bGwsbnVsbCx0aGlzLGEsYil9LApidjpmdW5jdGlvbihhLGIsYyxkKXtjLkMo
-IkA8MD4iKS5LcShkKS5DKCIxKDIpIikuYShhKQpkLmEoYikKaWYoJC5YMz09PUMuTlUpcmV0dXJuIGEu
-JDEoYikKcmV0dXJuIFAueXYobnVsbCxudWxsLHRoaXMsYSxiLGMsZCl9LApycDpmdW5jdGlvbihhLGIs
-YyxkLGUsZil7ZC5DKCJAPDA+IikuS3EoZSkuS3EoZikuQygiMSgyLDMpIikuYShhKQplLmEoYikKZi5h
-KGMpCmlmKCQuWDM9PT1DLk5VKXJldHVybiBhLiQyKGIsYykKcmV0dXJuIFAuUXgobnVsbCxudWxsLHRo
-aXMsYSxiLGMsZCxlLGYpfSwKTGo6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGIuQygiQDwwPiIpLktx
-KGMpLktxKGQpLkMoIjEoMiwzKSIpLmEoYSl9fQpQLmhqLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7
-cmV0dXJuIHRoaXMuYS56eih0aGlzLmIsdGhpcy5jKX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMu
-Yy5DKCIwKCkiKX19ClAuVnAucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmJI
-KHRoaXMuYil9LAokUzowfQpQLk9SLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMu
-YwpyZXR1cm4gdGhpcy5hLkRsKHRoaXMuYixzLmEoYSkscyl9LAokUzpmdW5jdGlvbigpe3JldHVybiB0
-aGlzLmMuQygifigwKSIpfX0KUC5iNi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlz
-LHI9bmV3IFAubG0ocyxzLnIsSC5MaChzKS5DKCJsbTwxPiIpKQpyLmM9cy5lCnJldHVybiByfSwKZ0E6
-ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09
-MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hIT09MH0sCnRnOmZ1bmN0aW9uKGEsYil7dmFy
-IHMscgppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIil7cz10aGlzLmIKaWYocz09
-bnVsbClyZXR1cm4hMQpyZXR1cm4gdC5lLmEoc1tiXSkhPW51bGx9ZWxzZXtyPXRoaXMuUFIoYikKcmV0
-dXJuIHJ9fSwKUFI6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJuITEKcmV0
-dXJuIHRoaXMuUihzW3RoaXMuTihhKV0sYSk+PTB9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRo
-aXMKSC5MaChxKS5jLmEoYikKaWYodHlwZW9mIGI9PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpe3M9
-cS5iCnJldHVybiBxLlMocz09bnVsbD9xLmI9UC5UMigpOnMsYil9ZWxzZSBpZih0eXBlb2YgYj09Im51
-bWJlciImJihiJjEwNzM3NDE4MjMpPT09Yil7cj1xLmMKcmV0dXJuIHEuUyhyPT1udWxsP3EuYz1QLlQy
-KCk6cixiKX1lbHNlIHJldHVybiBxLkcoYil9LApHOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMK
-SC5MaChwKS5jLmEoYSkKcz1wLmQKaWYocz09bnVsbClzPXAuZD1QLlQyKCkKcj1wLk4oYSkKcT1zW3Jd
-CmlmKHE9PW51bGwpc1tyXT1bcC5IKGEpXQplbHNle2lmKHAuUihxLGEpPj0wKXJldHVybiExCnEucHVz
-aChwLkgoYSkpfXJldHVybiEwfSwKTDpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMKaWYodHlwZW9mIGI9
-PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpcmV0dXJuIHMuSDQocy5iLGIpCmVsc2UgaWYodHlwZW9m
-IGI9PSJudW1iZXIiJiYoYiYxMDczNzQxODIzKT09PWIpcmV0dXJuIHMuSDQocy5jLGIpCmVsc2UgcmV0
-dXJuIHMucWcoYil9LApxZzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1vLmQKaWYobj09
-bnVsbClyZXR1cm4hMQpzPW8uTihhKQpyPW5bc10KcT1vLlIocixhKQppZihxPDApcmV0dXJuITEKcD1y
-LnNwbGljZShxLDEpWzBdCmlmKDA9PT1yLmxlbmd0aClkZWxldGUgbltzXQpvLkdTKHApCnJldHVybiEw
-fSwKUzpmdW5jdGlvbihhLGIpe0guTGgodGhpcykuYy5hKGIpCmlmKHQuZS5hKGFbYl0pIT1udWxsKXJl
-dHVybiExCmFbYl09dGhpcy5IKGIpCnJldHVybiEwfSwKSDQ6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihh
-PT1udWxsKXJldHVybiExCnM9dC5lLmEoYVtiXSkKaWYocz09bnVsbClyZXR1cm4hMQp0aGlzLkdTKHMp
-CmRlbGV0ZSBhW2JdCnJldHVybiEwfSwKR1k6ZnVuY3Rpb24oKXt0aGlzLnI9dGhpcy5yKzEmMTA3Mzc0
-MTgyM30sCkg6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLHE9bmV3IFAuYm4oSC5MaChyKS5jLmEoYSkp
-CmlmKHIuZT09bnVsbClyLmU9ci5mPXEKZWxzZXtzPXIuZgpzLnRvU3RyaW5nCnEuYz1zCnIuZj1zLmI9
-cX0rK3IuYQpyLkdZKCkKcmV0dXJuIHF9LApHUzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9YS5jLHE9
-YS5iCmlmKHI9PW51bGwpcy5lPXEKZWxzZSByLmI9cQppZihxPT1udWxsKXMuZj1yCmVsc2UgcS5jPXI7
-LS1zLmEKcy5HWSgpfSwKTjpmdW5jdGlvbihhKXtyZXR1cm4gSi5oZihhKSYxMDczNzQxODIzfSwKUjpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoYT09bnVsbClyZXR1cm4tMQpzPWEubGVuZ3RoCmZvcihyPTA7
-cjxzOysrcilpZihKLlJNKGFbcl0uYSxiKSlyZXR1cm4gcgpyZXR1cm4tMX19ClAuYm4ucHJvdG90eXBl
-PXt9ClAubG0ucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlv
-bigpe3ZhciBzPXRoaXMscj1zLmMscT1zLmEKaWYocy5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQpl
-bHNlIGlmKHI9PW51bGwpe3Muc2oobnVsbCkKcmV0dXJuITF9ZWxzZXtzLnNqKHMuJHRpLkMoIjE/Iiku
-YShyLmEpKQpzLmM9ci5iCnJldHVybiEwfX0sCnNqOmZ1bmN0aW9uKGEpe3RoaXMuZD10aGlzLiR0aS5D
-KCIxPyIpLmEoYSl9LAokaUFuOjF9ClAubVcucHJvdG90eXBlPXt9ClAudXkucHJvdG90eXBlPXskaWJR
-OjEsJGljWDoxLCRpek06MX0KUC5sRC5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3
-IEguYTcoYSx0aGlzLmdBKGEpLEgueihhKS5DKCJhNzxsRC5FPiIpKX0sCkU6ZnVuY3Rpb24oYSxiKXty
-ZXR1cm4gdGhpcy5xKGEsYil9LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILnooYSkuQygifihsRC5F
-KSIpLmEoYikKcz10aGlzLmdBKGEpCmZvcihyPTA7cjxzOysrcil7Yi4kMSh0aGlzLnEoYSxyKSkKaWYo
-cyE9PXRoaXMuZ0EoYSkpdGhyb3cgSC5iKFAuYTQoYSkpfX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4g
-dGhpcy5nQShhKT09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIXRoaXMuZ2wwKGEpfSwKRTI6ZnVu
-Y3Rpb24oYSxiLGMpe3ZhciBzPUgueihhKQpyZXR1cm4gbmV3IEgubEooYSxzLktxKGMpLkMoIjEobEQu
-RSkiKS5hKGIpLHMuQygiQDxsRC5FPiIpLktxKGMpLkMoImxKPDEsMj4iKSl9LAplUjpmdW5jdGlvbihh
-LGIpe3JldHVybiBILnFDKGEsYixudWxsLEgueihhKS5DKCJsRC5FIikpfSwKZHI6ZnVuY3Rpb24oYSxi
-KXtyZXR1cm4gbmV3IEgualYoYSxILnooYSkuQygiQDxsRC5FPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9
-LApkdTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcwpILnooYSkuQygibEQuRT8iKS5hKGQpClAuakIoYixj
-LHRoaXMuZ0EoYSkpCmZvcihzPWI7czxjOysrcyl0aGlzLlk1KGEscyxkKX0sCnc6ZnVuY3Rpb24oYSl7
-cmV0dXJuIFAuV0UoYSwiWyIsIl0iKX19ClAuaWwucHJvdG90eXBlPXt9ClAucmEucHJvdG90eXBlPXsK
-JDI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuYQppZighci5hKXRoaXMuYi5hKz0iLCAiCnIuYT0h
-MQpyPXRoaXMuYgpzPXIuYSs9SC5FaihhKQpyLmE9cysiOiAiCnIuYSs9SC5FaihiKX0sCiRTOjEwfQpQ
-LllrLnByb3RvdHlwZT17Cks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCkguTGgodGhpcykuQygifihZay5L
-LFlrLlYpIikuYShiKQpmb3Iocz1KLklUKHRoaXMuZ3ZjKCkpO3MuRigpOyl7cj1zLmdsKCkKYi4kMihy
-LHRoaXMucSgwLHIpKX19LApnUHU6ZnVuY3Rpb24oYSl7cmV0dXJuIEouTTEodGhpcy5ndmMoKSxuZXcg
-UC55USh0aGlzKSxILkxoKHRoaXMpLkMoIk4zPFlrLkssWWsuVj4iKSl9LAp4NDpmdW5jdGlvbihhKXty
-ZXR1cm4gSi56bCh0aGlzLmd2YygpLGEpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhpcy5n
-dmMoKSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudVUodGhpcy5ndmMoKSl9LAp3OmZ1bmN0aW9u
-KGEpe3JldHVybiBQLm5PKHRoaXMpfSwKJGlaMDoxfQpQLnlRLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
-KGEpe3ZhciBzPXRoaXMuYSxyPUguTGgocykKci5DKCJZay5LIikuYShhKQpyZXR1cm4gbmV3IFAuTjMo
-YSxzLnEoMCxhKSxyLkMoIkA8WWsuSz4iKS5LcShyLkMoIllrLlYiKSkuQygiTjM8MSwyPiIpKX0sCiRT
-OmZ1bmN0aW9uKCl7cmV0dXJuIEguTGgodGhpcy5hKS5DKCJOMzxZay5LLFlrLlY+KFlrLkspIil9fQpQ
-LktQLnByb3RvdHlwZT17Clk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnMuYy5hKGIp
-CnMuUVsxXS5hKGMpCnRocm93IEguYihQLkw0KCJDYW5ub3QgbW9kaWZ5IHVubW9kaWZpYWJsZSBtYXAi
-KSl9fQpQLlBuLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5hLnEoMCxiKX0s
-Clk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnRoaXMuYS5ZNSgwLHMuYy5hKGIpLHMu
-UVsxXS5hKGMpKX0sCng0OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEueDQoYSl9LApLOmZ1bmN0aW9u
-KGEsYil7dGhpcy5hLksoMCxILkxoKHRoaXMpLkMoIn4oMSwyKSIpLmEoYikpfSwKZ2wwOmZ1bmN0aW9u
-KGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nbDAocyl9LApnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlz
-LmEKcmV0dXJuIHMuZ0Eocyl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBKLmoodGhpcy5hKX0sCmdQdTpm
-dW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ1B1KHMpfSwKJGlaMDoxfQpQLkdqLnByb3Rv
-dHlwZT17fQpQLmxmLnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlz
-KT09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcykhPT0wfSwKRlY6ZnVuY3Rp
-b24oYSxiKXt2YXIgcwpmb3Iocz1KLklUKEguTGgodGhpcykuQygiY1g8bGYuRT4iKS5hKGIpKTtzLkYo
-KTspdGhpcy5pKDAscy5nbCgpKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFAuV0UodGhpcywieyIsIn0i
-KX0sCms6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuZ20odGhpcykKaWYoIXIuRigpKXJldHVybiIi
-CmlmKGI9PT0iIil7cz0iIgpkbyBzKz1ILkVqKHIuZCkKd2hpbGUoci5GKCkpfWVsc2V7cz1ILkVqKHIu
-ZCkKZm9yKDtyLkYoKTspcz1zK2IrSC5FaihyLmQpfXJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpz
-fSwKZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5iSyh0aGlzLGIsSC5MaCh0aGlzKS5DKCJsZi5FIikp
-fSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPSJpbmRleCIKSC5jYihiLHAsdC5TKQpQLmsxKGIs
-cCkKZm9yKHM9dGhpcy5nbSh0aGlzKSxyPTA7cy5GKCk7KXtxPXMuZAppZihiPT09cilyZXR1cm4gcTsr
-K3J9dGhyb3cgSC5iKFAuQ2YoYix0aGlzLHAsbnVsbCxyKSl9fQpQLlZqLnByb3RvdHlwZT17JGliUTox
-LCRpY1g6MSwkaXh1OjF9ClAuWHYucHJvdG90eXBlPXskaWJROjEsJGljWDoxLCRpeHU6MX0KUC5uWS5w
-cm90b3R5cGU9e30KUC5XWS5wcm90b3R5cGU9e30KUC5SVS5wcm90b3R5cGU9e30KUC5wUi5wcm90b3R5
-cGU9e30KUC51dy5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmIKaWYocj09
-bnVsbClyZXR1cm4gdGhpcy5jLnEoMCxiKQplbHNlIGlmKHR5cGVvZiBiIT0ic3RyaW5nIilyZXR1cm4g
-bnVsbAplbHNle3M9cltiXQpyZXR1cm4gdHlwZW9mIHM9PSJ1bmRlZmluZWQiP3RoaXMuZmIoYik6c319
-LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5iPT1udWxsP3RoaXMuYy5hOnRoaXMuQ2YoKS5sZW5n
-dGh9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcyk9PT0wfSwKZ3ZjOmZ1bmN0aW9u
-KCl7aWYodGhpcy5iPT1udWxsKXt2YXIgcz10aGlzLmMKcmV0dXJuIG5ldyBILmk1KHMsSC5MaChzKS5D
-KCJpNTwxPiIpKX1yZXR1cm4gbmV3IFAuaTgodGhpcyl9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMs
-cixxPXRoaXMKaWYocS5iPT1udWxsKXEuYy5ZNSgwLGIsYykKZWxzZSBpZihxLng0KGIpKXtzPXEuYgpz
-W2JdPWMKcj1xLmEKaWYocj09bnVsbD9zIT1udWxsOnIhPT1zKXJbYl09bnVsbH1lbHNlIHEuWEsoKS5Z
-NSgwLGIsYyl9LAp4NDpmdW5jdGlvbihhKXtpZih0aGlzLmI9PW51bGwpcmV0dXJuIHRoaXMuYy54NChh
-KQpyZXR1cm4gT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKHRoaXMuYSxhKX0sCks6
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvPXRoaXMKdC5jQS5hKGIpCmlmKG8uYj09bnVsbClyZXR1
-cm4gby5jLksoMCxiKQpzPW8uQ2YoKQpmb3Iocj0wO3I8cy5sZW5ndGg7KytyKXtxPXNbcl0KcD1vLmJb
-cV0KaWYodHlwZW9mIHA9PSJ1bmRlZmluZWQiKXtwPVAuUWUoby5hW3FdKQpvLmJbcV09cH1iLiQyKHEs
-cCkKaWYocyE9PW8uYyl0aHJvdyBILmIoUC5hNChvKSl9fSwKQ2Y6ZnVuY3Rpb24oKXt2YXIgcz10LmJN
-LmEodGhpcy5jKQppZihzPT1udWxsKXM9dGhpcy5jPUguVk0oT2JqZWN0LmtleXModGhpcy5hKSx0LnMp
-CnJldHVybiBzfSwKWEs6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG49dGhpcwppZihuLmI9PW51bGwp
-cmV0dXJuIG4uYwpzPVAuRmwodC5OLHQueikKcj1uLkNmKCkKZm9yKHE9MDtwPXIubGVuZ3RoLHE8cDsr
-K3Epe289cltxXQpzLlk1KDAsbyxuLnEoMCxvKSl9aWYocD09PTApQy5ObS5pKHIsIiIpCmVsc2UgQy5O
-bS5zQShyLDApCm4uYT1uLmI9bnVsbApyZXR1cm4gbi5jPXN9LApmYjpmdW5jdGlvbihhKXt2YXIgcwpp
-ZighT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKHRoaXMuYSxhKSlyZXR1cm4gbnVs
-bApzPVAuUWUodGhpcy5hW2FdKQpyZXR1cm4gdGhpcy5iW2FdPXN9fQpQLmk4LnByb3RvdHlwZT17CmdB
-OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nQShzKX0sCkU6ZnVuY3Rpb24oYSxiKXt2
-YXIgcz10aGlzLmEKaWYocy5iPT1udWxsKXM9cy5ndmMoKS5FKDAsYikKZWxzZXtzPXMuQ2YoKQppZihi
-PDB8fGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcz1zW2JdfXJldHVybiBzfSwKZ206ZnVuY3Rp
-b24oYSl7dmFyIHM9dGhpcy5hCmlmKHMuYj09bnVsbCl7cz1zLmd2YygpCnM9cy5nbShzKX1lbHNle3M9
-cy5DZigpCnM9bmV3IEoubTEocyxzLmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfXJldHVybiBzfSwK
-dGc6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5hLng0KGIpfX0KUC5wZy5wcm90b3R5cGU9ewokMDpm
-dW5jdGlvbigpe3ZhciBzLHIKdHJ5e3M9bmV3IFRleHREZWNvZGVyKCJ1dGYtOCIse2ZhdGFsOnRydWV9
-KQpyZXR1cm4gc31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxsfSwKJFM6MTF9ClAuYzIucHJvdG90
-eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyCnRyeXtzPW5ldyBUZXh0RGVjb2RlcigidXRmLTgiLHtm
-YXRhbDpmYWxzZX0pCnJldHVybiBzfWNhdGNoKHIpe0guUnUocil9cmV0dXJuIG51bGx9LAokUzoxMX0K
-UC5DVi5wcm90b3R5cGU9ewp5cjpmdW5jdGlvbihhMCxhMSxhMil7dmFyIHMscixxLHAsbyxuLG0sbCxr
-LGosaSxoLGcsZixlLGQsYyxiLGE9IkludmFsaWQgYmFzZTY0IGVuY29kaW5nIGxlbmd0aCAiCmEyPVAu
-akIoYTEsYTIsYTAubGVuZ3RoKQpzPSQuVjcoKQpmb3Iocj1hMSxxPXIscD1udWxsLG89LTEsbj0tMSxt
-PTA7cjxhMjtyPWwpe2w9cisxCms9Qy54Qi5XKGEwLHIpCmlmKGs9PT0zNyl7aj1sKzIKaWYoajw9YTIp
-e2k9SC5vbyhDLnhCLlcoYTAsbCkpCmg9SC5vbyhDLnhCLlcoYTAsbCsxKSkKZz1pKjE2K2gtKGgmMjU2
-KQppZihnPT09MzcpZz0tMQpsPWp9ZWxzZSBnPS0xfWVsc2UgZz1rCmlmKDA8PWcmJmc8PTEyNyl7aWYo
-ZzwwfHxnPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGcpCmY9c1tnXQppZihmPj0wKXtnPUMueEIuTzIo
-IkFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2
-Nzg5Ky8iLGYpCmlmKGc9PT1rKWNvbnRpbnVlCms9Z31lbHNle2lmKGY9PT0tMSl7aWYobzwwKXtlPXA9
-PW51bGw/bnVsbDpwLmEubGVuZ3RoCmlmKGU9PW51bGwpZT0wCm89ZSsoci1xKQpuPXJ9KyttCmlmKGs9
-PT02MSljb250aW51ZX1rPWd9aWYoZiE9PS0yKXtpZihwPT1udWxsKXtwPW5ldyBQLlJuKCIiKQplPXB9
-ZWxzZSBlPXAKZS5hKz1DLnhCLk5qKGEwLHEscikKZS5hKz1ILkx3KGspCnE9bApjb250aW51ZX19dGhy
-b3cgSC5iKFAucnIoIkludmFsaWQgYmFzZTY0IGRhdGEiLGEwLHIpKX1pZihwIT1udWxsKXtlPXAuYSs9
-Qy54Qi5OaihhMCxxLGEyKQpkPWUubGVuZ3RoCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxkKQplbHNl
-e2M9Qy5qbi56WShkLTEsNCkrMQppZihjPT09MSl0aHJvdyBILmIoUC5ycihhLGEwLGEyKSkKZm9yKDtj
-PDQ7KXtlKz0iPSIKcC5hPWU7KytjfX1lPXAuYQpyZXR1cm4gQy54Qi5pNyhhMCxhMSxhMixlLmNoYXJD
-b2RlQXQoMCk9PTA/ZTplKX1iPWEyLWExCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxiKQplbHNle2M9
-Qy5qbi56WShiLDQpCmlmKGM9PT0xKXRocm93IEguYihQLnJyKGEsYTAsYTIpKQppZihjPjEpYTA9Qy54
-Qi5pNyhhMCxhMixhMixjPT09Mj8iPT0iOiI9Iil9cmV0dXJuIGEwfX0KUC5VOC5wcm90b3R5cGU9e30K
-UC5Vay5wcm90b3R5cGU9e30KUC53SS5wcm90b3R5cGU9e30KUC5aaS5wcm90b3R5cGU9e30KUC5VZC5w
-cm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPVAucCh0aGlzLmEpCnJldHVybih0aGlzLmIhPW51
-bGw/IkNvbnZlcnRpbmcgb2JqZWN0IHRvIGFuIGVuY29kYWJsZSBvYmplY3QgZmFpbGVkOiI6IkNvbnZl
-cnRpbmcgb2JqZWN0IGRpZCBub3QgcmV0dXJuIGFuIGVuY29kYWJsZSBvYmplY3Q6IikrIiAiK3N9fQpQ
-Lks4LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkN5Y2xpYyBlcnJvciBpbiBKU09OIHN0
-cmluZ2lmeSJ9fQpQLmJ5LnByb3RvdHlwZT17CnBXOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwp0LmZWLmEo
-YykKcz1QLkJTKGIsdGhpcy5nSGUoKS5hKQpyZXR1cm4gc30sCk9COmZ1bmN0aW9uKGEsYil7dmFyIHMK
-dC5kQS5hKGIpCnM9UC51WChhLHRoaXMuZ1pFKCkuYixudWxsKQpyZXR1cm4gc30sCmdaRTpmdW5jdGlv
-bigpe3JldHVybiBDLm5YfSwKZ0hlOmZ1bmN0aW9uKCl7cmV0dXJuIEMuQTN9fQpQLm9qLnByb3RvdHlw
-ZT17fQpQLk14LnByb3RvdHlwZT17fQpQLlNoLnByb3RvdHlwZT17CnZwOmZ1bmN0aW9uKGEpe3ZhciBz
-LHIscSxwLG8sbixtLGw9YS5sZW5ndGgKZm9yKHM9Si5yWShhKSxyPXRoaXMuYyxxPTAscD0wO3A8bDsr
-K3Ape289cy5XKGEscCkKaWYobz45Mil7aWYobz49NTUyOTYpe249byY2NDUxMgppZihuPT09NTUyOTYp
-e209cCsxCm09IShtPGwmJihDLnhCLlcoYSxtKSY2NDUxMik9PT01NjMyMCl9ZWxzZSBtPSExCmlmKCFt
-KWlmKG49PT01NjMyMCl7bj1wLTEKbj0hKG4+PTAmJihDLnhCLk8yKGEsbikmNjQ1MTIpPT09NTUyOTYp
-fWVsc2Ugbj0hMQplbHNlIG49ITAKaWYobil7aWYocD5xKXIuYSs9Qy54Qi5OaihhLHEscCkKcT1wKzEK
-ci5hKz1ILkx3KDkyKQpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoMTAwKQpuPW8+Pj44JjE1CnIuYSs9
-SC5MdyhuPDEwPzQ4K246ODcrbikKbj1vPj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pCm49
-byYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pfX1jb250aW51ZX1pZihvPDMyKXtpZihwPnEpci5h
-Kz1DLnhCLk5qKGEscSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnN3aXRjaChvKXtjYXNlIDg6ci5hKz1I
-Lkx3KDk4KQpicmVhawpjYXNlIDk6ci5hKz1ILkx3KDExNikKYnJlYWsKY2FzZSAxMDpyLmErPUguTHco
-MTEwKQpicmVhawpjYXNlIDEyOnIuYSs9SC5MdygxMDIpCmJyZWFrCmNhc2UgMTM6ci5hKz1ILkx3KDEx
-NCkKYnJlYWsKZGVmYXVsdDpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoNDgpCnIuYSs9SC5Mdyg0OCkK
-bj1vPj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pCm49byYxNQpyLmErPUguTHcobjwxMD80
-OCtuOjg3K24pCmJyZWFrfX1lbHNlIGlmKG89PT0zNHx8bz09PTkyKXtpZihwPnEpci5hKz1DLnhCLk5q
-KGEscSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnIuYSs9SC5MdyhvKX19aWYocT09PTApci5hKz1ILkVq
-KGEpCmVsc2UgaWYocTxsKXIuYSs9cy5OaihhLHEsbCl9LApKbjpmdW5jdGlvbihhKXt2YXIgcyxyLHEs
-cApmb3Iocz10aGlzLmEscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1zW3FdCmlmKGE9PW51bGw/cD09
-bnVsbDphPT09cCl0aHJvdyBILmIobmV3IFAuSzgoYSxudWxsKSl9Qy5ObS5pKHMsYSl9LAppVTpmdW5j
-dGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMKaWYoby50TShhKSlyZXR1cm4Kby5KbihhKQp0cnl7cz1v
-LmIuJDEoYSkKaWYoIW8udE0ocykpe3E9UC5HeShhLG51bGwsby5nVksoKSkKdGhyb3cgSC5iKHEpfXE9
-by5hCmlmKDA+PXEubGVuZ3RoKXJldHVybiBILk9IKHEsLTEpCnEucG9wKCl9Y2F0Y2gocCl7cj1ILlJ1
-KHApCnE9UC5HeShhLHIsby5nVksoKSkKdGhyb3cgSC5iKHEpfX0sCnRNOmZ1bmN0aW9uKGEpe3ZhciBz
-LHIscT10aGlzCmlmKHR5cGVvZiBhPT0ibnVtYmVyIil7aWYoIWlzRmluaXRlKGEpKXJldHVybiExCnEu
-Yy5hKz1DLkNELncoYSkKcmV0dXJuITB9ZWxzZSBpZihhPT09ITApe3EuYy5hKz0idHJ1ZSIKcmV0dXJu
-ITB9ZWxzZSBpZihhPT09ITEpe3EuYy5hKz0iZmFsc2UiCnJldHVybiEwfWVsc2UgaWYoYT09bnVsbCl7
-cS5jLmErPSJudWxsIgpyZXR1cm4hMH1lbHNlIGlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz1xLmMKcy5h
-Kz0nIicKcS52cChhKQpzLmErPSciJwpyZXR1cm4hMH1lbHNlIGlmKHQuai5iKGEpKXtxLkpuKGEpCnEu
-bEsoYSkKcz1xLmEKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpyZXR1cm4h
-MH1lbHNlIGlmKHQuZi5iKGEpKXtxLkpuKGEpCnI9cS5qdyhhKQpzPXEuYQppZigwPj1zLmxlbmd0aCly
-ZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnJldHVybiByfWVsc2UgcmV0dXJuITF9LApsSzpmdW5jdGlv
-bihhKXt2YXIgcyxyLHE9dGhpcy5jCnEuYSs9IlsiCnM9Si5VNihhKQppZihzLmdvcihhKSl7dGhpcy5p
-VShzLnEoYSwwKSkKZm9yKHI9MTtyPHMuZ0EoYSk7KytyKXtxLmErPSIsIgp0aGlzLmlVKHMucShhLHIp
-KX19cS5hKz0iXSJ9LApqdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9e30KaWYo
-YS5nbDAoYSkpe20uYy5hKz0ie30iCnJldHVybiEwfXM9YS5nQShhKSoyCnI9UC5POChzLG51bGwsITEs
-dC5XKQpxPWwuYT0wCmwuYj0hMAphLksoMCxuZXcgUC50aShsLHIpKQppZighbC5iKXJldHVybiExCnA9
-bS5jCnAuYSs9InsiCmZvcihvPSciJztxPHM7cSs9MixvPScsIicpe3AuYSs9bwptLnZwKEguaChyW3Fd
-KSkKcC5hKz0nIjonCm49cSsxCmlmKG4+PXMpcmV0dXJuIEguT0gocixuKQptLmlVKHJbbl0pfXAuYSs9
-In0iCnJldHVybiEwfX0KUC50aS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYo
-dHlwZW9mIGEhPSJzdHJpbmciKXRoaXMuYS5iPSExCnM9dGhpcy5iCnI9dGhpcy5hCkMuTm0uWTUocyxy
-LmErKyxhKQpDLk5tLlk1KHMsci5hKyssYil9LAokUzoxMH0KUC50dS5wcm90b3R5cGU9ewpnVks6ZnVu
-Y3Rpb24oKXt2YXIgcz10aGlzLmMuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c319ClAudTUu
-cHJvdG90eXBlPXsKZ1pFOmZ1bmN0aW9uKCl7cmV0dXJuIEMuUWt9fQpQLkUzLnByb3RvdHlwZT17CldK
-OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPVAuakIoMCxudWxsLGEubGVuZ3RoKSxvPXAtMAppZihvPT09
-MClyZXR1cm4gbmV3IFVpbnQ4QXJyYXkoMCkKcz1vKjMKcj1uZXcgVWludDhBcnJheShzKQpxPW5ldyBQ
-LlJ3KHIpCmlmKHEuR3goYSwwLHApIT09cCl7Si5hNihhLHAtMSkKcS5STygpfXJldHVybiBuZXcgVWlu
-dDhBcnJheShyLnN1YmFycmF5KDAsSC5yTSgwLHEuYixzKSkpfX0KUC5Sdy5wcm90b3R5cGU9ewpSTzpm
-dW5jdGlvbigpe3ZhciBzPXRoaXMscj1zLmMscT1zLmIscD1zLmI9cSsxLG89ci5sZW5ndGgKaWYocT49
-bylyZXR1cm4gSC5PSChyLHEpCnJbcV09MjM5CnE9cy5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIs
-cCkKcltwXT0xOTEKcy5iPXErMQppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT0xODl9LApPNjpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj10aGlzCmlmKChiJjY0NTEyKT09PTU2MzIwKXtzPTY1
-NTM2KygoYSYxMDIzKTw8MTApfGImMTAyMwpyPW4uYwpxPW4uYgpwPW4uYj1xKzEKbz1yLmxlbmd0aApp
-ZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT1zPj4+MTh8MjQwCnE9bi5iPXArMQppZihwPj1vKXJl
-dHVybiBILk9IKHIscCkKcltwXT1zPj4+MTImNjN8MTI4CnA9bi5iPXErMQppZihxPj1vKXJldHVybiBI
-Lk9IKHIscSkKcltxXT1zPj4+NiY2M3wxMjgKbi5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkK
-cltwXT1zJjYzfDEyOApyZXR1cm4hMH1lbHNle24uUk8oKQpyZXR1cm4hMX19LApHeDpmdW5jdGlvbihh
-LGIsYyl7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzCmlmKGIhPT1jJiYoQy54Qi5PMihhLGMtMSkmNjQ1
-MTIpPT09NTUyOTYpLS1jCmZvcihzPWwuYyxyPXMubGVuZ3RoLHE9YjtxPGM7KytxKXtwPUMueEIuVyhh
-LHEpCmlmKHA8PTEyNyl7bz1sLmIKaWYobz49cilicmVhawpsLmI9bysxCnNbb109cH1lbHNle289cCY2
-NDUxMgppZihvPT09NTUyOTYpe2lmKGwuYis0PnIpYnJlYWsKbj1xKzEKaWYobC5PNihwLEMueEIuVyhh
-LG4pKSlxPW59ZWxzZSBpZihvPT09NTYzMjApe2lmKGwuYiszPnIpYnJlYWsKbC5STygpfWVsc2UgaWYo
-cDw9MjA0Nyl7bz1sLmIKbT1vKzEKaWYobT49cilicmVhawpsLmI9bQppZihvPj1yKXJldHVybiBILk9I
-KHMsbykKc1tvXT1wPj4+NnwxOTIKbC5iPW0rMQpzW21dPXAmNjN8MTI4fWVsc2V7bz1sLmIKaWYobysy
-Pj1yKWJyZWFrCm09bC5iPW8rMQppZihvPj1yKXJldHVybiBILk9IKHMsbykKc1tvXT1wPj4+MTJ8MjI0
-Cm89bC5iPW0rMQppZihtPj1yKXJldHVybiBILk9IKHMsbSkKc1ttXT1wPj4+NiY2M3wxMjgKbC5iPW8r
-MQppZihvPj1yKXJldHVybiBILk9IKHMsbykKc1tvXT1wJjYzfDEyOH19fXJldHVybiBxfX0KUC5HWS5w
-cm90b3R5cGU9ewpXSjpmdW5jdGlvbihhKXt2YXIgcyxyCnQuTC5hKGEpCnM9dGhpcy5hCnI9UC5reShz
-LGEsMCxudWxsKQppZihyIT1udWxsKXJldHVybiByCnJldHVybiBuZXcgUC5ieihzKS5OZShhLDAsbnVs
-bCwhMCl9fQpQLmJ6LnByb3RvdHlwZT17Ck5lOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG8s
-bj10aGlzCnQuTC5hKGEpCnM9UC5qQihiLGMsSi5IbShhKSkKaWYoYj09PXMpcmV0dXJuIiIKcj1QLmp5
-KGEsYixzKQpxPW4uaE8ociwwLHMtYiwhMCkKcD1uLmIKaWYoKHAmMSkhPT0wKXtvPVAuajQocCkKbi5i
-PTAKdGhyb3cgSC5iKFAucnIobyxhLGIrbi5jKSl9cmV0dXJuIHF9LApoTzpmdW5jdGlvbihhLGIsYyxk
-KXt2YXIgcyxyLHE9dGhpcwppZihjLWI+MTAwMCl7cz1DLmpuLkJVKGIrYywyKQpyPXEuaE8oYSxiLHMs
-ITEpCmlmKChxLmImMSkhPT0wKXJldHVybiByCnJldHVybiByK3EuaE8oYSxzLGMsZCl9cmV0dXJuIHEu
-RWgoYSxiLGMsZCl9LApFaDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhp
-cyxqPTY1NTMzLGk9ay5iLGg9ay5jLGc9bmV3IFAuUm4oIiIpLGY9YisxLGU9YS5sZW5ndGgKaWYoYjww
-fHxiPj1lKXJldHVybiBILk9IKGEsYikKcz1hW2JdCiRsYWJlbDAkMDpmb3Iocj1rLmE7ITA7KXtmb3Io
-OyEwO2Y9byl7cT1DLnhCLlcoIkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
+fQpILlBxLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCkgub2QoYixhLGEubGVuZ3Ro
+KQpyZXR1cm4gYVtiXX19CkguZUUucHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVu
+Z3RofSwKcTpmdW5jdGlvbihhLGIpe0gudVAoYikKSC5vZChiLGEsYS5sZW5ndGgpCnJldHVybiBhW2Jd
+fX0KSC5WNi5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0
+aW9uKGEsYil7SC51UChiKQpILm9kKGIsYSxhLmxlbmd0aCkKcmV0dXJuIGFbYl19LAokaVY2OjEsCiRp
+bjY6MX0KSC5SRy5wcm90b3R5cGU9e30KSC5WUC5wcm90b3R5cGU9e30KSC5XQi5wcm90b3R5cGU9e30K
+SC5aRy5wcm90b3R5cGU9e30KSC5KYy5wcm90b3R5cGU9ewpDOmZ1bmN0aW9uKGEpe3JldHVybiBILmNF
+KHYudHlwZVVuaXZlcnNlLHRoaXMsYSl9LApLcTpmdW5jdGlvbihhKXtyZXR1cm4gSC52NSh2LnR5cGVV
+bml2ZXJzZSx0aGlzLGEpfX0KSC5HLnByb3RvdHlwZT17fQpILmxZLnByb3RvdHlwZT17Cnc6ZnVuY3Rp
+b24oYSl7cmV0dXJuIEguZG0odGhpcy5hLG51bGwpfX0KSC5rUy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9u
+KGEpe3JldHVybiB0aGlzLmF9fQpILmlNLnByb3RvdHlwZT17fQpQLnRoLnByb3RvdHlwZT17CiQxOmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuYSxyPXMuYQpzLmE9bnVsbApyLiQwKCl9LAokUzo5fQpQLmhhLnBy
+b3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIKdGhpcy5hLmE9dC5NLmEoYSkKcz10aGlzLmIK
+cj10aGlzLmMKcy5maXJzdENoaWxkP3MucmVtb3ZlQ2hpbGQocik6cy5hcHBlbmRDaGlsZChyKX0sCiRT
+OjM0fQpQLlZzLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLiQwKCl9LAokQzoiJDAiLAok
+UjowLAokUzoyfQpQLkZ0LnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dGhpcy5hLiQwKCl9LAokQzoi
+JDAiLAokUjowLAokUzoyfQpQLlczLnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYil7aWYoc2VsZi5z
+ZXRUaW1lb3V0IT1udWxsKXNlbGYuc2V0VGltZW91dChILnRSKG5ldyBQLnlIKHRoaXMsYiksMCksYSkK
+ZWxzZSB0aHJvdyBILmIoUC5MNCgiYHNldFRpbWVvdXQoKWAgbm90IGZvdW5kLiIpKX19ClAueUgucHJv
+dG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt0aGlzLmIuJDAoKX0sCiRDOiIkMCIsCiRSOjAsCiRTOjB9ClAu
+aWgucHJvdG90eXBlPXsKYU06ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMscT1yLiR0aQpxLkMoIjEv
+PyIpLmEoYikKaWYoIXIuYilyLmEuWGYoYikKZWxzZXtzPXIuYQppZihxLkMoImI4PDE+IikuYihiKSlz
+LmNVKGIpCmVsc2Ugcy5YMihxLmMuYShiKSl9fSwKdzA6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihiPT1u
+dWxsKWI9UC52MChhKQpzPXRoaXMuYQppZih0aGlzLmIpcy5aTChhLGIpCmVsc2Ugcy5OayhhLGIpfX0K
+UC5XTS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLiQyKDAsYSl9LAokUzo1
+Mn0KUC5TWC5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMuYS4kMigxLG5ldyBILmJxKGEs
+dC5sLmEoYikpKX0sCiRDOiIkMiIsCiRSOjIsCiRTOjI0fQpQLkdzLnByb3RvdHlwZT17CiQyOmZ1bmN0
+aW9uKGEsYil7dGhpcy5hKEgudVAoYSksYil9LAokUzoyNn0KUC5GeS5wcm90b3R5cGU9ewp3OmZ1bmN0
+aW9uKGEpe3JldHVybiJJdGVyYXRpb25NYXJrZXIoIit0aGlzLmIrIiwgIitILkVqKHRoaXMuYSkrIiki
+fX0KUC5HVi5wcm90b3R5cGU9ewpnbDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuYwppZihzPT1udWxsKXJl
+dHVybiB0aGlzLiR0aS5jLmEodGhpcy5iKQpyZXR1cm4gcy5nbCgpfSwKRjpmdW5jdGlvbigpe3ZhciBz
+LHIscSxwLG8sbixtPXRoaXMKZm9yKHM9bS4kdGkuQygiQW48MT4iKTshMDspe3I9bS5jCmlmKHIhPW51
+bGwpaWYoci5GKCkpcmV0dXJuITAKZWxzZSBtLnNYOShudWxsKQpxPWZ1bmN0aW9uKGEsYixjKXt2YXIg
+bCxrPWIKd2hpbGUodHJ1ZSl0cnl7cmV0dXJuIGEoayxsKX1jYXRjaChqKXtsPWoKaz1jfX0obS5hLDAs
+MSkKaWYocSBpbnN0YW5jZW9mIFAuRnkpe3A9cS5iCmlmKHA9PT0yKXtvPW0uZAppZihvPT1udWxsfHxv
+Lmxlbmd0aD09PTApe20uc0VDKG51bGwpCnJldHVybiExfWlmKDA+PW8ubGVuZ3RoKXJldHVybiBILk9I
+KG8sLTEpCm0uYT1vLnBvcCgpCmNvbnRpbnVlfWVsc2V7cj1xLmEKaWYocD09PTMpdGhyb3cgcgplbHNl
+e249cy5hKEouSVQocikpCmlmKG4gaW5zdGFuY2VvZiBQLkdWKXtyPW0uZAppZihyPT1udWxsKXI9bS5k
+PVtdCkMuTm0uaShyLG0uYSkKbS5hPW4uYQpjb250aW51ZX1lbHNle20uc1g5KG4pCmNvbnRpbnVlfX19
+fWVsc2V7bS5zRUMocSkKcmV0dXJuITB9fXJldHVybiExfSwKc0VDOmZ1bmN0aW9uKGEpe3RoaXMuYj10
+aGlzLiR0aS5DKCIxPyIpLmEoYSl9LApzWDk6ZnVuY3Rpb24oYSl7dGhpcy5jPXRoaXMuJHRpLkMoIkFu
+PDE+PyIpLmEoYSl9LAokaUFuOjF9ClAucTQucHJvdG90eXBlPXsKZ206ZnVuY3Rpb24oYSl7cmV0dXJu
+IG5ldyBQLkdWKHRoaXMuYSgpLHRoaXMuJHRpLkMoIkdWPDE+IikpfX0KUC5QZi5wcm90b3R5cGU9ewp3
+MDpmdW5jdGlvbihhLGIpe3ZhciBzCkguY2IoYSwiZXJyb3IiLHQuSykKcz10aGlzLmEKaWYocy5hIT09
+MCl0aHJvdyBILmIoUC5QVigiRnV0dXJlIGFscmVhZHkgY29tcGxldGVkIikpCmlmKGI9PW51bGwpYj1Q
+LnYwKGEpCnMuTmsoYSxiKX0sCnBtOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLncwKGEsbnVsbCl9fQpQ
+LlpmLnByb3RvdHlwZT17CmFNOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLiR0aQpyLkMoIjEvPyIp
+LmEoYikKcz10aGlzLmEKaWYocy5hIT09MCl0aHJvdyBILmIoUC5QVigiRnV0dXJlIGFscmVhZHkgY29t
+cGxldGVkIikpCnMuWGYoci5DKCIxLyIpLmEoYikpfX0KUC5GZS5wcm90b3R5cGU9ewpIUjpmdW5jdGlv
+bihhKXtpZigodGhpcy5jJjE1KSE9PTYpcmV0dXJuITAKcmV0dXJuIHRoaXMuYi5iLmJ2KHQuYWwuYSh0
+aGlzLmQpLGEuYSx0LnksdC5LKX0sCkt3OmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZSxyPXQueixxPXQu
+SyxwPXRoaXMuJHRpLkMoIjIvIiksbz10aGlzLmIuYgppZih0LmFnLmIocykpcmV0dXJuIHAuYShvLnJw
+KHMsYS5hLGEuYixyLHEsdC5sKSkKZWxzZSByZXR1cm4gcC5hKG8uYnYodC5iSS5hKHMpLGEuYSxyLHEp
+KX19ClAudnMucHJvdG90eXBlPXsKU3E6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscSxwPXRoaXMuJHRp
+CnAuS3EoYykuQygiMS8oMikiKS5hKGEpCnM9JC5YMwppZihzIT09Qy5OVSl7Yy5DKCJAPDAvPiIpLktx
+KHAuYykuQygiMSgyKSIpLmEoYSkKaWYoYiE9bnVsbCliPVAuVkgoYixzKX1yPW5ldyBQLnZzKHMsYy5D
+KCJ2czwwPiIpKQpxPWI9PW51bGw/MTozCnRoaXMueGYobmV3IFAuRmUocixxLGEsYixwLkMoIkA8MT4i
+KS5LcShjKS5DKCJGZTwxLDI+IikpKQpyZXR1cm4gcn0sClc3OmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRo
+aXMuU3EoYSxudWxsLGIpfSwKUWQ6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHI9dGhpcy4kdGkKci5LcShj
+KS5DKCIxLygyKSIpLmEoYSkKcz1uZXcgUC52cygkLlgzLGMuQygidnM8MD4iKSkKdGhpcy54ZihuZXcg
+UC5GZShzLDE5LGEsYixyLkMoIkA8MT4iKS5LcShjKS5DKCJGZTwxLDI+IikpKQpyZXR1cm4gc30sCnhm
+OmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcyxxPXIuYQppZihxPD0xKXthLmE9dC5GLmEoci5jKQpyLmM9
+YX1lbHNle2lmKHE9PT0yKXtzPXQuYy5hKHIuYykKcT1zLmEKaWYocTw0KXtzLnhmKGEpCnJldHVybn1y
+LmE9cQpyLmM9cy5jfVAuVGsobnVsbCxudWxsLHIuYix0Lk0uYShuZXcgUC5kYShyLGEpKSl9fSwKalE6
+ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG09dGhpcyxsPXt9CmwuYT1hCmlmKGE9PW51bGwpcmV0
+dXJuCnM9bS5hCmlmKHM8PTEpe3I9dC5GLmEobS5jKQptLmM9YQppZihyIT1udWxsKXtxPWEuYQpmb3Io
+cD1hO3EhPW51bGw7cD1xLHE9bylvPXEuYQpwLmE9cn19ZWxzZXtpZihzPT09Mil7bj10LmMuYShtLmMp
+CnM9bi5hCmlmKHM8NCl7bi5qUShhKQpyZXR1cm59bS5hPXMKbS5jPW4uY31sLmE9bS5OOChhKQpQLlRr
+KG51bGwsbnVsbCxtLmIsdC5NLmEobmV3IFAub1EobCxtKSkpfX0sCmFoOmZ1bmN0aW9uKCl7dmFyIHM9
+dC5GLmEodGhpcy5jKQp0aGlzLmM9bnVsbApyZXR1cm4gdGhpcy5OOChzKX0sCk44OmZ1bmN0aW9uKGEp
+e3ZhciBzLHIscQpmb3Iocz1hLHI9bnVsbDtzIT1udWxsO3I9cyxzPXEpe3E9cy5hCnMuYT1yfXJldHVy
+biByfSwKZWM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9dGhpcwpwLmE9MQp0cnl7YS5TcShuZXcgUC5w
+VihwKSxuZXcgUC5VNyhwKSx0LlApfWNhdGNoKHEpe3M9SC5SdShxKQpyPUgudHMocSkKUC5yYihuZXcg
+UC52cihwLHMscikpfX0sClgyOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcwpyLiR0aS5jLmEoYSkKcz1y
+LmFoKCkKci5hPTQKci5jPWEKUC5IWihyLHMpfSwKWkw6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9dGhp
+cwp0LmwuYShiKQpzPXEuYWgoKQpyPVAuVGwoYSxiKQpxLmE9OApxLmM9cgpQLkhaKHEscyl9LApYZjpm
+dW5jdGlvbihhKXt2YXIgcz10aGlzLiR0aQpzLkMoIjEvIikuYShhKQppZihzLkMoImI4PDE+IikuYihh
+KSl7dGhpcy5jVShhKQpyZXR1cm59dGhpcy53VShzLmMuYShhKSl9LAp3VTpmdW5jdGlvbihhKXt2YXIg
+cz10aGlzCnMuJHRpLmMuYShhKQpzLmE9MQpQLlRrKG51bGwsbnVsbCxzLmIsdC5NLmEobmV3IFAucnQo
+cyxhKSkpfSwKY1U6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcyxyPXMuJHRpCnIuQygiYjg8MT4iKS5hKGEp
+CmlmKHIuYihhKSl7aWYoYS5hPT09OCl7cy5hPTEKUC5UayhudWxsLG51bGwscy5iLHQuTS5hKG5ldyBQ
+LktGKHMsYSkpKX1lbHNlIFAuQTkoYSxzKQpyZXR1cm59cy5lYyhhKX0sCk5rOmZ1bmN0aW9uKGEsYil7
+dGhpcy5hPTEKUC5UayhudWxsLG51bGwsdGhpcy5iLHQuTS5hKG5ldyBQLlpMKHRoaXMsYSxiKSkpfSwK
+JGliODoxfQpQLmRhLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7UC5IWih0aGlzLmEsdGhpcy5iKX0s
+CiRTOjB9ClAub1EucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtQLkhaKHRoaXMuYix0aGlzLmEuYSl9
+LAokUzowfQpQLnBWLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMuYQpw
+LmE9MAp0cnl7cC5YMihwLiR0aS5jLmEoYSkpfWNhdGNoKHEpe3M9SC5SdShxKQpyPUgudHMocSkKcC5a
+TChzLHIpfX0sCiRTOjl9ClAuVTcucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuWkwo
+YSx0LmwuYShiKSl9LAokQzoiJDIiLAokUjoyLAokUzoyOX0KUC52ci5wcm90b3R5cGU9ewokMDpmdW5j
+dGlvbigpe3RoaXMuYS5aTCh0aGlzLmIsdGhpcy5jKX0sCiRTOjB9ClAucnQucHJvdG90eXBlPXsKJDA6
+ZnVuY3Rpb24oKXt0aGlzLmEuWDIodGhpcy5iKX0sCiRTOjB9ClAuS0YucHJvdG90eXBlPXsKJDA6ZnVu
+Y3Rpb24oKXtQLkE5KHRoaXMuYix0aGlzLmEpfSwKJFM6MH0KUC5aTC5wcm90b3R5cGU9ewokMDpmdW5j
+dGlvbigpe3RoaXMuYS5aTCh0aGlzLmIsdGhpcy5jKX0sCiRTOjB9ClAuUlQucHJvdG90eXBlPXsKJDA6
+ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9bnVsbAp0cnl7cT1tLmEuYQpsPXEuYi5i
+Lnp6KHQuZk8uYShxLmQpLHQueil9Y2F0Y2gocCl7cz1ILlJ1KHApCnI9SC50cyhwKQppZihtLmMpe3E9
+dC5uLmEobS5iLmEuYykuYQpvPXMKbz1xPT1udWxsP289PW51bGw6cT09PW8KcT1vfWVsc2UgcT0hMQpv
+PW0uYQppZihxKW8uYz10Lm4uYShtLmIuYS5jKQplbHNlIG8uYz1QLlRsKHMscikKby5iPSEwCnJldHVy
+bn1pZihsIGluc3RhbmNlb2YgUC52cyYmbC5hPj00KXtpZihsLmE9PT04KXtxPW0uYQpxLmM9dC5uLmEo
+bC5jKQpxLmI9ITB9cmV0dXJufWlmKHQuZS5iKGwpKXtuPW0uYi5hCnE9bS5hCnEuYz1sLlc3KG5ldyBQ
+LmpaKG4pLHQueikKcS5iPSExfX0sCiRTOjB9ClAualoucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7
+cmV0dXJuIHRoaXMuYX0sCiRTOjMyfQpQLnJxLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7dmFyIHMs
+cixxLHAsbyxuLG0sbAp0cnl7cT10aGlzLmEKcD1xLmEKbz1wLiR0aQpuPW8uYwptPW4uYSh0aGlzLmIp
+CnEuYz1wLmIuYi5idihvLkMoIjIvKDEpIikuYShwLmQpLG0sby5DKCIyLyIpLG4pfWNhdGNoKGwpe3M9
+SC5SdShsKQpyPUgudHMobCkKcT10aGlzLmEKcS5jPVAuVGwocyxyKQpxLmI9ITB9fSwKJFM6MH0KUC5S
+Vy5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGwsaz10aGlzCnRyeXtz
+PXQubi5hKGsuYS5hLmMpCnA9ay5iCmlmKEgub1QocC5hLkhSKHMpKSYmcC5hLmUhPW51bGwpe3AuYz1w
+LmEuS3cocykKcC5iPSExfX1jYXRjaChvKXtyPUguUnUobykKcT1ILnRzKG8pCnA9dC5uLmEoay5hLmEu
+YykKbj1wLmEKbT1yCmw9ay5iCmlmKG49PW51bGw/bT09bnVsbDpuPT09bSlsLmM9cAplbHNlIGwuYz1Q
+LlRsKHIscSkKbC5iPSEwfX0sCiRTOjB9ClAuT00ucHJvdG90eXBlPXt9ClAucWgucHJvdG90eXBlPXsK
+Z0E6ZnVuY3Rpb24oYSl7dmFyIHMscixxPXRoaXMscD17fSxvPW5ldyBQLnZzKCQuWDMsdC5mSikKcC5h
+PTAKcz1ILkxoKHEpCnI9cy5DKCJ+KDEpPyIpLmEobmV3IFAuQjUocCxxKSkKdC5aLmEobmV3IFAudU8o
+cCxvKSkKVy5KRShxLmEscS5iLHIsITEscy5jKQpyZXR1cm4gb319ClAuQjUucHJvdG90eXBlPXsKJDE6
+ZnVuY3Rpb24oYSl7SC5MaCh0aGlzLmIpLmMuYShhKTsrK3RoaXMuYS5hfSwKJFM6ZnVuY3Rpb24oKXty
+ZXR1cm4gSC5MaCh0aGlzLmIpLkMoIn4oMSkiKX19ClAudU8ucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24o
+KXt2YXIgcz10aGlzLmIscj1zLiR0aSxxPXIuQygiMS8iKS5hKHRoaXMuYS5hKSxwPXMuYWgoKQpyLmMu
+YShxKQpzLmE9NApzLmM9cQpQLkhaKHMscCl9LAokUzowfQpQLk1PLnByb3RvdHlwZT17fQpQLmtULnBy
+b3RvdHlwZT17fQpQLnhJLnByb3RvdHlwZT17fQpQLkN3LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7
+cmV0dXJuIEguRWoodGhpcy5hKX0sCiRpWFM6MSwKZ0lJOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYn19
+ClAubTAucHJvdG90eXBlPXskaVFtOjF9ClAucEsucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXt2YXIg
+cz1ILmIodGhpcy5hKQpzLnN0YWNrPUouaih0aGlzLmIpCnRocm93IHN9LAokUzowfQpQLkppLnByb3Rv
+dHlwZT17CmJIOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPW51bGwKdC5NLmEoYSkKdHJ5e2lmKEMuTlU9
+PT0kLlgzKXthLiQwKCkKcmV0dXJufVAuVDgocCxwLHRoaXMsYSx0LkgpfWNhdGNoKHEpe3M9SC5SdShx
+KQpyPUgudHMocSkKUC5MMihwLHAsdGhpcyxzLHQubC5hKHIpKX19LApEbDpmdW5jdGlvbihhLGIsYyl7
+dmFyIHMscixxLHA9bnVsbApjLkMoIn4oMCkiKS5hKGEpCmMuYShiKQp0cnl7aWYoQy5OVT09PSQuWDMp
+e2EuJDEoYikKcmV0dXJufVAueXYocCxwLHRoaXMsYSxiLHQuSCxjKX1jYXRjaChxKXtzPUguUnUocSkK
+cj1ILnRzKHEpClAuTDIocCxwLHRoaXMscyx0LmwuYShyKSl9fSwKUlQ6ZnVuY3Rpb24oYSxiKXtyZXR1
+cm4gbmV3IFAuaGoodGhpcyxiLkMoIjAoKSIpLmEoYSksYil9LAp0ODpmdW5jdGlvbihhKXtyZXR1cm4g
+bmV3IFAuVnAodGhpcyx0Lk0uYShhKSl9LApQeTpmdW5jdGlvbihhLGIpe3JldHVybiBuZXcgUC5PUih0
+aGlzLGIuQygifigwKSIpLmEoYSksYil9LApxOmZ1bmN0aW9uKGEsYil7cmV0dXJuIG51bGx9LAp6ejpm
+dW5jdGlvbihhLGIpe2IuQygiMCgpIikuYShhKQppZigkLlgzPT09Qy5OVSlyZXR1cm4gYS4kMCgpCnJl
+dHVybiBQLlQ4KG51bGwsbnVsbCx0aGlzLGEsYil9LApidjpmdW5jdGlvbihhLGIsYyxkKXtjLkMoIkA8
+MD4iKS5LcShkKS5DKCIxKDIpIikuYShhKQpkLmEoYikKaWYoJC5YMz09PUMuTlUpcmV0dXJuIGEuJDEo
+YikKcmV0dXJuIFAueXYobnVsbCxudWxsLHRoaXMsYSxiLGMsZCl9LApycDpmdW5jdGlvbihhLGIsYyxk
+LGUsZil7ZC5DKCJAPDA+IikuS3EoZSkuS3EoZikuQygiMSgyLDMpIikuYShhKQplLmEoYikKZi5hKGMp
+CmlmKCQuWDM9PT1DLk5VKXJldHVybiBhLiQyKGIsYykKcmV0dXJuIFAuUXgobnVsbCxudWxsLHRoaXMs
+YSxiLGMsZCxlLGYpfSwKTGo6ZnVuY3Rpb24oYSxiLGMsZCl7cmV0dXJuIGIuQygiQDwwPiIpLktxKGMp
+LktxKGQpLkMoIjEoMiwzKSIpLmEoYSl9fQpQLmhqLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7cmV0
+dXJuIHRoaXMuYS56eih0aGlzLmIsdGhpcy5jKX0sCiRTOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuYy5D
+KCIwKCkiKX19ClAuVnAucHJvdG90eXBlPXsKJDA6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5hLmJIKHRo
+aXMuYil9LAokUzowfQpQLk9SLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYwpy
+ZXR1cm4gdGhpcy5hLkRsKHRoaXMuYixzLmEoYSkscyl9LAokUzpmdW5jdGlvbigpe3JldHVybiB0aGlz
+LmMuQygifigwKSIpfX0KUC5iNi5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9
+bmV3IFAubG0ocyxzLnIsSC5MaChzKS5DKCJsbTwxPiIpKQpyLmM9cy5lCnJldHVybiByfSwKZ0E6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIHRoaXMuYX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hPT09MH0s
+CmdvcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hIT09MH0sCnRnOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cgppZih0eXBlb2YgYj09InN0cmluZyImJmIhPT0iX19wcm90b19fIil7cz10aGlzLmIKaWYocz09bnVs
+bClyZXR1cm4hMQpyZXR1cm4gdC5tLmEoc1tiXSkhPW51bGx9ZWxzZXtyPXRoaXMuUFIoYikKcmV0dXJu
+IHJ9fSwKUFI6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5kCmlmKHM9PW51bGwpcmV0dXJuITEKcmV0dXJu
+IHRoaXMuUihzW3RoaXMuTihhKV0sYSk+PTB9LAppOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPXRoaXMK
+SC5MaChxKS5jLmEoYikKaWYodHlwZW9mIGI9PSJzdHJpbmciJiZiIT09Il9fcHJvdG9fXyIpe3M9cS5i
+CnJldHVybiBxLlMocz09bnVsbD9xLmI9UC5UMigpOnMsYil9ZWxzZSBpZih0eXBlb2YgYj09Im51bWJl
+ciImJihiJjEwNzM3NDE4MjMpPT09Yil7cj1xLmMKcmV0dXJuIHEuUyhyPT1udWxsP3EuYz1QLlQyKCk6
+cixiKX1lbHNlIHJldHVybiBxLkcoYil9LApHOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwPXRoaXMKSC5M
+aChwKS5jLmEoYSkKcz1wLmQKaWYocz09bnVsbClzPXAuZD1QLlQyKCkKcj1wLk4oYSkKcT1zW3JdCmlm
+KHE9PW51bGwpc1tyXT1bcC5IKGEpXQplbHNle2lmKHAuUihxLGEpPj0wKXJldHVybiExCnEucHVzaChw
+LkgoYSkpfXJldHVybiEwfSwKTDpmdW5jdGlvbihhLGIpe3ZhciBzPXRoaXMKaWYodHlwZW9mIGI9PSJz
+dHJpbmciJiZiIT09Il9fcHJvdG9fXyIpcmV0dXJuIHMuSDQocy5iLGIpCmVsc2UgaWYodHlwZW9mIGI9
+PSJudW1iZXIiJiYoYiYxMDczNzQxODIzKT09PWIpcmV0dXJuIHMuSDQocy5jLGIpCmVsc2UgcmV0dXJu
+IHMucWcoYil9LApxZzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1vLmQKaWYobj09bnVs
+bClyZXR1cm4hMQpzPW8uTihhKQpyPW5bc10KcT1vLlIocixhKQppZihxPDApcmV0dXJuITEKcD1yLnNw
+bGljZShxLDEpWzBdCmlmKDA9PT1yLmxlbmd0aClkZWxldGUgbltzXQpvLkdTKHApCnJldHVybiEwfSwK
+UzpmdW5jdGlvbihhLGIpe0guTGgodGhpcykuYy5hKGIpCmlmKHQubS5hKGFbYl0pIT1udWxsKXJldHVy
+biExCmFbYl09dGhpcy5IKGIpCnJldHVybiEwfSwKSDQ6ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihhPT1u
+dWxsKXJldHVybiExCnM9dC5tLmEoYVtiXSkKaWYocz09bnVsbClyZXR1cm4hMQp0aGlzLkdTKHMpCmRl
+bGV0ZSBhW2JdCnJldHVybiEwfSwKR1k6ZnVuY3Rpb24oKXt0aGlzLnI9dGhpcy5yKzEmMTA3Mzc0MTgy
+M30sCkg6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLHE9bmV3IFAuYm4oSC5MaChyKS5jLmEoYSkpCmlm
+KHIuZT09bnVsbClyLmU9ci5mPXEKZWxzZXtzPXIuZgpzLnRvU3RyaW5nCnEuYz1zCnIuZj1zLmI9cX0r
+K3IuYQpyLkdZKCkKcmV0dXJuIHF9LApHUzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9YS5jLHE9YS5i
+CmlmKHI9PW51bGwpcy5lPXEKZWxzZSByLmI9cQppZihxPT1udWxsKXMuZj1yCmVsc2UgcS5jPXI7LS1z
+LmEKcy5HWSgpfSwKTjpmdW5jdGlvbihhKXtyZXR1cm4gSi5oZihhKSYxMDczNzQxODIzfSwKUjpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIKaWYoYT09bnVsbClyZXR1cm4tMQpzPWEubGVuZ3RoCmZvcihyPTA7cjxz
+OysrcilpZihKLlJNKGFbcl0uYSxiKSlyZXR1cm4gcgpyZXR1cm4tMX19ClAuYm4ucHJvdG90eXBlPXt9
+ClAubG0ucHJvdG90eXBlPXsKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKRjpmdW5jdGlvbigp
+e3ZhciBzPXRoaXMscj1zLmMscT1zLmEKaWYocy5iIT09cS5yKXRocm93IEguYihQLmE0KHEpKQplbHNl
+IGlmKHI9PW51bGwpe3Muc2oobnVsbCkKcmV0dXJuITF9ZWxzZXtzLnNqKHMuJHRpLkMoIjE/IikuYShy
+LmEpKQpzLmM9ci5iCnJldHVybiEwfX0sCnNqOmZ1bmN0aW9uKGEpe3RoaXMuZD10aGlzLiR0aS5DKCIx
+PyIpLmEoYSl9LAokaUFuOjF9ClAubVcucHJvdG90eXBlPXt9ClAudXkucHJvdG90eXBlPXskaWJROjEs
+JGljWDoxLCRpek06MX0KUC5sRC5wcm90b3R5cGU9ewpnbTpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IEgu
+YTcoYSx0aGlzLmdBKGEpLEgueihhKS5DKCJhNzxsRC5FPiIpKX0sCkU6ZnVuY3Rpb24oYSxiKXtyZXR1
+cm4gdGhpcy5xKGEsYil9LApLOmZ1bmN0aW9uKGEsYil7dmFyIHMscgpILnooYSkuQygifihsRC5FKSIp
+LmEoYikKcz10aGlzLmdBKGEpCmZvcihyPTA7cjxzOysrcil7Yi4kMSh0aGlzLnEoYSxyKSkKaWYocyE9
+PXRoaXMuZ0EoYSkpdGhyb3cgSC5iKFAuYTQoYSkpfX0sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
+cy5nQShhKT09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIXRoaXMuZ2wwKGEpfSwKRTI6ZnVuY3Rp
+b24oYSxiLGMpe3ZhciBzPUgueihhKQpyZXR1cm4gbmV3IEgubEooYSxzLktxKGMpLkMoIjEobEQuRSki
+KS5hKGIpLHMuQygiQDxsRC5FPiIpLktxKGMpLkMoImxKPDEsMj4iKSl9LAplUjpmdW5jdGlvbihhLGIp
+e3JldHVybiBILnFDKGEsYixudWxsLEgueihhKS5DKCJsRC5FIikpfSwKZHI6ZnVuY3Rpb24oYSxiKXty
+ZXR1cm4gbmV3IEgualYoYSxILnooYSkuQygiQDxsRC5FPiIpLktxKGIpLkMoImpWPDEsMj4iKSl9LApk
+dTpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcwpILnooYSkuQygibEQuRT8iKS5hKGQpClAuakIoYixjLHRo
+aXMuZ0EoYSkpCmZvcihzPWI7czxjOysrcyl0aGlzLlk1KGEscyxkKX0sCnc6ZnVuY3Rpb24oYSl7cmV0
+dXJuIFAuV0UoYSwiWyIsIl0iKX19ClAuaWwucHJvdG90eXBlPXt9ClAucmEucHJvdG90eXBlPXsKJDI6
+ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuYQppZighci5hKXRoaXMuYi5hKz0iLCAiCnIuYT0hMQpy
+PXRoaXMuYgpzPXIuYSs9SC5FaihhKQpyLmE9cysiOiAiCnIuYSs9SC5FaihiKX0sCiRTOjEwfQpQLllr
+LnByb3RvdHlwZT17Cks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCkguTGgodGhpcykuQygifihZay5LLFlr
+LlYpIikuYShiKQpmb3Iocz1KLklUKHRoaXMuZ3ZjKCkpO3MuRigpOyl7cj1zLmdsKCkKYi4kMihyLHRo
+aXMucSgwLHIpKX19LApnUHU6ZnVuY3Rpb24oYSl7cmV0dXJuIEouTTEodGhpcy5ndmMoKSxuZXcgUC55
+USh0aGlzKSxILkxoKHRoaXMpLkMoIk4zPFlrLkssWWsuVj4iKSl9LAp4NDpmdW5jdGlvbihhKXtyZXR1
+cm4gSi56bCh0aGlzLmd2YygpLGEpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIEouSG0odGhpcy5ndmMo
+KSl9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIEoudVUodGhpcy5ndmMoKSl9LAp3OmZ1bmN0aW9uKGEp
+e3JldHVybiBQLm5PKHRoaXMpfSwKJGlaMDoxfQpQLnlRLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
+e3ZhciBzPXRoaXMuYSxyPUguTGgocykKci5DKCJZay5LIikuYShhKQpyZXR1cm4gbmV3IFAuTjMoYSxz
+LnEoMCxhKSxyLkMoIkA8WWsuSz4iKS5LcShyLkMoIllrLlYiKSkuQygiTjM8MSwyPiIpKX0sCiRTOmZ1
+bmN0aW9uKCl7cmV0dXJuIEguTGgodGhpcy5hKS5DKCJOMzxZay5LLFlrLlY+KFlrLkspIil9fQpQLktQ
+LnByb3RvdHlwZT17Clk1OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnMuYy5hKGIpCnMu
+UVsxXS5hKGMpCnRocm93IEguYihQLkw0KCJDYW5ub3QgbW9kaWZ5IHVubW9kaWZpYWJsZSBtYXAiKSl9
+fQpQLlBuLnByb3RvdHlwZT17CnE6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5hLnEoMCxiKX0sClk1
+OmZ1bmN0aW9uKGEsYixjKXt2YXIgcz1ILkxoKHRoaXMpCnRoaXMuYS5ZNSgwLHMuYy5hKGIpLHMuUVsx
+XS5hKGMpKX0sCng0OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEueDQoYSl9LApLOmZ1bmN0aW9uKGEs
+Yil7dGhpcy5hLksoMCxILkxoKHRoaXMpLkMoIn4oMSwyKSIpLmEoYikpfSwKZ2wwOmZ1bmN0aW9uKGEp
+e3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nbDAocyl9LApnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEK
+cmV0dXJuIHMuZ0Eocyl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBKLmoodGhpcy5hKX0sCmdQdTpmdW5j
+dGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHMuZ1B1KHMpfSwKJGlaMDoxfQpQLkdqLnByb3RvdHlw
+ZT17fQpQLmxmLnByb3RvdHlwZT17CmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nQSh0aGlzKT09
+PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcykhPT0wfSwKRlY6ZnVuY3Rpb24o
+YSxiKXt2YXIgcwpmb3Iocz1KLklUKEguTGgodGhpcykuQygiY1g8bGYuRT4iKS5hKGIpKTtzLkYoKTsp
+dGhpcy5pKDAscy5nbCgpKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIFAuV0UodGhpcywieyIsIn0iKX0s
+Cms6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuZ20odGhpcykKaWYoIXIuRigpKXJldHVybiIiCmlm
+KGI9PT0iIil7cz0iIgpkbyBzKz1ILkVqKHIuZCkKd2hpbGUoci5GKCkpfWVsc2V7cz1ILkVqKHIuZCkK
+Zm9yKDtyLkYoKTspcz1zK2IrSC5FaihyLmQpfXJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwK
+ZVI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5iSyh0aGlzLGIsSC5MaCh0aGlzKS5DKCJsZi5FIikpfSwK
+RTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwPSJpbmRleCIKSC5jYihiLHAsdC5TKQpQLmsxKGIscCkK
+Zm9yKHM9dGhpcy5nbSh0aGlzKSxyPTA7cy5GKCk7KXtxPXMuZAppZihiPT09cilyZXR1cm4gcTsrK3J9
+dGhyb3cgSC5iKFAuQ2YoYix0aGlzLHAsbnVsbCxyKSl9fQpQLlZqLnByb3RvdHlwZT17JGliUToxLCRp
+Y1g6MSwkaXh1OjF9ClAuWHYucHJvdG90eXBlPXskaWJROjEsJGljWDoxLCRpeHU6MX0KUC5uWS5wcm90
+b3R5cGU9e30KUC5XWS5wcm90b3R5cGU9e30KUC5SVS5wcm90b3R5cGU9e30KUC5wUi5wcm90b3R5cGU9
+e30KUC51dy5wcm90b3R5cGU9ewpxOmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmIKaWYocj09bnVs
+bClyZXR1cm4gdGhpcy5jLnEoMCxiKQplbHNlIGlmKHR5cGVvZiBiIT0ic3RyaW5nIilyZXR1cm4gbnVs
+bAplbHNle3M9cltiXQpyZXR1cm4gdHlwZW9mIHM9PSJ1bmRlZmluZWQiP3RoaXMuZmIoYik6c319LApn
+QTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5iPT1udWxsP3RoaXMuYy5hOnRoaXMuQ2YoKS5sZW5ndGh9
+LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ0EodGhpcyk9PT0wfSwKZ3ZjOmZ1bmN0aW9uKCl7
+aWYodGhpcy5iPT1udWxsKXt2YXIgcz10aGlzLmMKcmV0dXJuIG5ldyBILmk1KHMsSC5MaChzKS5DKCJp
+NTwxPiIpKX1yZXR1cm4gbmV3IFAuaTgodGhpcyl9LApZNTpmdW5jdGlvbihhLGIsYyl7dmFyIHMscixx
+PXRoaXMKaWYocS5iPT1udWxsKXEuYy5ZNSgwLGIsYykKZWxzZSBpZihxLng0KGIpKXtzPXEuYgpzW2Jd
+PWMKcj1xLmEKaWYocj09bnVsbD9zIT1udWxsOnIhPT1zKXJbYl09bnVsbH1lbHNlIHEuWEsoKS5ZNSgw
+LGIsYyl9LAp4NDpmdW5jdGlvbihhKXtpZih0aGlzLmI9PW51bGwpcmV0dXJuIHRoaXMuYy54NChhKQpy
+ZXR1cm4gT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKHRoaXMuYSxhKX0sCks6ZnVu
+Y3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvPXRoaXMKdC5jQS5hKGIpCmlmKG8uYj09bnVsbClyZXR1cm4g
+by5jLksoMCxiKQpzPW8uQ2YoKQpmb3Iocj0wO3I8cy5sZW5ndGg7KytyKXtxPXNbcl0KcD1vLmJbcV0K
+aWYodHlwZW9mIHA9PSJ1bmRlZmluZWQiKXtwPVAuUWUoby5hW3FdKQpvLmJbcV09cH1iLiQyKHEscCkK
+aWYocyE9PW8uYyl0aHJvdyBILmIoUC5hNChvKSl9fSwKQ2Y6ZnVuY3Rpb24oKXt2YXIgcz10LmJNLmEo
+dGhpcy5jKQppZihzPT1udWxsKXM9dGhpcy5jPUguVk0oT2JqZWN0LmtleXModGhpcy5hKSx0LnMpCnJl
+dHVybiBzfSwKWEs6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG49dGhpcwppZihuLmI9PW51bGwpcmV0
+dXJuIG4uYwpzPVAuRmwodC5OLHQueikKcj1uLkNmKCkKZm9yKHE9MDtwPXIubGVuZ3RoLHE8cDsrK3Ep
+e289cltxXQpzLlk1KDAsbyxuLnEoMCxvKSl9aWYocD09PTApQy5ObS5pKHIsIiIpCmVsc2UgQy5ObS5z
+QShyLDApCm4uYT1uLmI9bnVsbApyZXR1cm4gbi5jPXN9LApmYjpmdW5jdGlvbihhKXt2YXIgcwppZigh
+T2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKHRoaXMuYSxhKSlyZXR1cm4gbnVsbApz
+PVAuUWUodGhpcy5hW2FdKQpyZXR1cm4gdGhpcy5iW2FdPXN9fQpQLmk4LnByb3RvdHlwZT17CmdBOmZ1
+bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4gcy5nQShzKX0sCkU6ZnVuY3Rpb24oYSxiKXt2YXIg
+cz10aGlzLmEKaWYocy5iPT1udWxsKXM9cy5ndmMoKS5FKDAsYikKZWxzZXtzPXMuQ2YoKQppZihiPDB8
+fGI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYikKcz1zW2JdfXJldHVybiBzfSwKZ206ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcy5hCmlmKHMuYj09bnVsbCl7cz1zLmd2YygpCnM9cy5nbShzKX1lbHNle3M9cy5D
+ZigpCnM9bmV3IEoubTEocyxzLmxlbmd0aCxILnQ2KHMpLkMoIm0xPDE+IikpfXJldHVybiBzfSwKdGc6
+ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5hLng0KGIpfX0KUC54ci5wcm90b3R5cGU9ewokMDpmdW5j
+dGlvbigpe3ZhciBzLHIKdHJ5e3M9bmV3IFRleHREZWNvZGVyKCJ1dGYtOCIse2ZhdGFsOnRydWV9KQpy
+ZXR1cm4gc31jYXRjaChyKXtILlJ1KHIpfXJldHVybiBudWxsfSwKJFM6MTF9ClAuTnoucHJvdG90eXBl
+PXsKJDA6ZnVuY3Rpb24oKXt2YXIgcyxyCnRyeXtzPW5ldyBUZXh0RGVjb2RlcigidXRmLTgiLHtmYXRh
+bDpmYWxzZX0pCnJldHVybiBzfWNhdGNoKHIpe0guUnUocil9cmV0dXJuIG51bGx9LAokUzoxMX0KUC5D
+Vi5wcm90b3R5cGU9ewp5cjpmdW5jdGlvbihhMCxhMSxhMil7dmFyIHMscixxLHAsbyxuLG0sbCxrLGos
+aSxoLGcsZixlLGQsYyxiLGE9IkludmFsaWQgYmFzZTY0IGVuY29kaW5nIGxlbmd0aCAiCmEyPVAuakIo
+YTEsYTIsYTAubGVuZ3RoKQpzPSQuVjcoKQpmb3Iocj1hMSxxPXIscD1udWxsLG89LTEsbj0tMSxtPTA7
+cjxhMjtyPWwpe2w9cisxCms9Qy54Qi5XKGEwLHIpCmlmKGs9PT0zNyl7aj1sKzIKaWYoajw9YTIpe2k9
+SC5vbyhDLnhCLlcoYTAsbCkpCmg9SC5vbyhDLnhCLlcoYTAsbCsxKSkKZz1pKjE2K2gtKGgmMjU2KQpp
+ZihnPT09MzcpZz0tMQpsPWp9ZWxzZSBnPS0xfWVsc2UgZz1rCmlmKDA8PWcmJmc8PTEyNyl7aWYoZzww
+fHxnPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGcpCmY9c1tnXQppZihmPj0wKXtnPUMueEIuTzIoIkFC
+Q0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5
+Ky8iLGYpCmlmKGc9PT1rKWNvbnRpbnVlCms9Z31lbHNle2lmKGY9PT0tMSl7aWYobzwwKXtlPXA9PW51
+bGw/bnVsbDpwLmEubGVuZ3RoCmlmKGU9PW51bGwpZT0wCm89ZSsoci1xKQpuPXJ9KyttCmlmKGs9PT02
+MSljb250aW51ZX1rPWd9aWYoZiE9PS0yKXtpZihwPT1udWxsKXtwPW5ldyBQLlJuKCIiKQplPXB9ZWxz
+ZSBlPXAKZS5hKz1DLnhCLk5qKGEwLHEscikKZS5hKz1ILkx3KGspCnE9bApjb250aW51ZX19dGhyb3cg
+SC5iKFAucnIoIkludmFsaWQgYmFzZTY0IGRhdGEiLGEwLHIpKX1pZihwIT1udWxsKXtlPXAuYSs9Qy54
+Qi5OaihhMCxxLGEyKQpkPWUubGVuZ3RoCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxkKQplbHNle2M9
+Qy5qbi56WShkLTEsNCkrMQppZihjPT09MSl0aHJvdyBILmIoUC5ycihhLGEwLGEyKSkKZm9yKDtjPDQ7
+KXtlKz0iPSIKcC5hPWU7KytjfX1lPXAuYQpyZXR1cm4gQy54Qi5pNyhhMCxhMSxhMixlLmNoYXJDb2Rl
+QXQoMCk9PTA/ZTplKX1iPWEyLWExCmlmKG8+PTApUC54TShhMCxuLGEyLG8sbSxiKQplbHNle2M9Qy5q
+bi56WShiLDQpCmlmKGM9PT0xKXRocm93IEguYihQLnJyKGEsYTAsYTIpKQppZihjPjEpYTA9Qy54Qi5p
+NyhhMCxhMixhMixjPT09Mj8iPT0iOiI9Iil9cmV0dXJuIGEwfX0KUC5VOC5wcm90b3R5cGU9e30KUC5V
+ay5wcm90b3R5cGU9e30KUC53SS5wcm90b3R5cGU9e30KUC5aaS5wcm90b3R5cGU9e30KUC5VZC5wcm90
+b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzPVAucCh0aGlzLmEpCnJldHVybih0aGlzLmIhPW51bGw/
+IkNvbnZlcnRpbmcgb2JqZWN0IHRvIGFuIGVuY29kYWJsZSBvYmplY3QgZmFpbGVkOiI6IkNvbnZlcnRp
+bmcgb2JqZWN0IGRpZCBub3QgcmV0dXJuIGFuIGVuY29kYWJsZSBvYmplY3Q6IikrIiAiK3N9fQpQLks4
+LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkN5Y2xpYyBlcnJvciBpbiBKU09OIHN0cmlu
+Z2lmeSJ9fQpQLmJ5LnByb3RvdHlwZT17CnBXOmZ1bmN0aW9uKGEsYixjKXt2YXIgcwp0LmZWLmEoYykK
+cz1QLkJTKGIsdGhpcy5nSGUoKS5hKQpyZXR1cm4gc30sCk9COmZ1bmN0aW9uKGEsYil7dmFyIHMKdC5k
+QS5hKGIpCnM9UC51WChhLHRoaXMuZ1pFKCkuYixudWxsKQpyZXR1cm4gc30sCmdaRTpmdW5jdGlvbigp
+e3JldHVybiBDLm5YfSwKZ0hlOmZ1bmN0aW9uKCl7cmV0dXJuIEMuQTN9fQpQLm9qLnByb3RvdHlwZT17
+fQpQLk14LnByb3RvdHlwZT17fQpQLlNoLnByb3RvdHlwZT17CnZwOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
+cSxwLG8sbixtLGw9YS5sZW5ndGgKZm9yKHM9Si5yWShhKSxyPXRoaXMuYyxxPTAscD0wO3A8bDsrK3Ap
+e289cy5XKGEscCkKaWYobz45Mil7aWYobz49NTUyOTYpe249byY2NDUxMgppZihuPT09NTUyOTYpe209
+cCsxCm09IShtPGwmJihDLnhCLlcoYSxtKSY2NDUxMik9PT01NjMyMCl9ZWxzZSBtPSExCmlmKCFtKWlm
+KG49PT01NjMyMCl7bj1wLTEKbj0hKG4+PTAmJihDLnhCLk8yKGEsbikmNjQ1MTIpPT09NTUyOTYpfWVs
+c2Ugbj0hMQplbHNlIG49ITAKaWYobil7aWYocD5xKXIuYSs9Qy54Qi5OaihhLHEscCkKcT1wKzEKci5h
+Kz1ILkx3KDkyKQpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoMTAwKQpuPW8+Pj44JjE1CnIuYSs9SC5M
+dyhuPDEwPzQ4K246ODcrbikKbj1vPj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pCm49byYx
+NQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pfX1jb250aW51ZX1pZihvPDMyKXtpZihwPnEpci5hKz1D
+LnhCLk5qKGEscSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnN3aXRjaChvKXtjYXNlIDg6ci5hKz1ILkx3
+KDk4KQpicmVhawpjYXNlIDk6ci5hKz1ILkx3KDExNikKYnJlYWsKY2FzZSAxMDpyLmErPUguTHcoMTEw
+KQpicmVhawpjYXNlIDEyOnIuYSs9SC5MdygxMDIpCmJyZWFrCmNhc2UgMTM6ci5hKz1ILkx3KDExNCkK
+YnJlYWsKZGVmYXVsdDpyLmErPUguTHcoMTE3KQpyLmErPUguTHcoNDgpCnIuYSs9SC5Mdyg0OCkKbj1v
+Pj4+NCYxNQpyLmErPUguTHcobjwxMD80OCtuOjg3K24pCm49byYxNQpyLmErPUguTHcobjwxMD80OCtu
+Ojg3K24pCmJyZWFrfX1lbHNlIGlmKG89PT0zNHx8bz09PTkyKXtpZihwPnEpci5hKz1DLnhCLk5qKGEs
+cSxwKQpxPXArMQpyLmErPUguTHcoOTIpCnIuYSs9SC5MdyhvKX19aWYocT09PTApci5hKz1ILkVqKGEp
+CmVsc2UgaWYocTxsKXIuYSs9cy5OaihhLHEsbCl9LApKbjpmdW5jdGlvbihhKXt2YXIgcyxyLHEscApm
+b3Iocz10aGlzLmEscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1zW3FdCmlmKGE9PW51bGw/cD09bnVs
+bDphPT09cCl0aHJvdyBILmIobmV3IFAuSzgoYSxudWxsKSl9Qy5ObS5pKHMsYSl9LAppVTpmdW5jdGlv
+bihhKXt2YXIgcyxyLHEscCxvPXRoaXMKaWYoby50TShhKSlyZXR1cm4Kby5KbihhKQp0cnl7cz1vLmIu
+JDEoYSkKaWYoIW8udE0ocykpe3E9UC5HeShhLG51bGwsby5nVksoKSkKdGhyb3cgSC5iKHEpfXE9by5h
+CmlmKDA+PXEubGVuZ3RoKXJldHVybiBILk9IKHEsLTEpCnEucG9wKCl9Y2F0Y2gocCl7cj1ILlJ1KHAp
+CnE9UC5HeShhLHIsby5nVksoKSkKdGhyb3cgSC5iKHEpfX0sCnRNOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
+cT10aGlzCmlmKHR5cGVvZiBhPT0ibnVtYmVyIil7aWYoIWlzRmluaXRlKGEpKXJldHVybiExCnEuYy5h
+Kz1DLkNELncoYSkKcmV0dXJuITB9ZWxzZSBpZihhPT09ITApe3EuYy5hKz0idHJ1ZSIKcmV0dXJuITB9
+ZWxzZSBpZihhPT09ITEpe3EuYy5hKz0iZmFsc2UiCnJldHVybiEwfWVsc2UgaWYoYT09bnVsbCl7cS5j
+LmErPSJudWxsIgpyZXR1cm4hMH1lbHNlIGlmKHR5cGVvZiBhPT0ic3RyaW5nIil7cz1xLmMKcy5hKz0n
+IicKcS52cChhKQpzLmErPSciJwpyZXR1cm4hMH1lbHNlIGlmKHQuai5iKGEpKXtxLkpuKGEpCnEubEso
+YSkKcz1xLmEKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpyZXR1cm4hMH1l
+bHNlIGlmKHQuZi5iKGEpKXtxLkpuKGEpCnI9cS5qdyhhKQpzPXEuYQppZigwPj1zLmxlbmd0aClyZXR1
+cm4gSC5PSChzLC0xKQpzLnBvcCgpCnJldHVybiByfWVsc2UgcmV0dXJuITF9LApsSzpmdW5jdGlvbihh
+KXt2YXIgcyxyLHE9dGhpcy5jCnEuYSs9IlsiCnM9Si5VNihhKQppZihzLmdvcihhKSl7dGhpcy5pVShz
+LnEoYSwwKSkKZm9yKHI9MTtyPHMuZ0EoYSk7KytyKXtxLmErPSIsIgp0aGlzLmlVKHMucShhLHIpKX19
+cS5hKz0iXSJ9LApqdzpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLGw9e30KaWYoYS5n
+bDAoYSkpe20uYy5hKz0ie30iCnJldHVybiEwfXM9YS5nQShhKSoyCnI9UC5POChzLG51bGwsITEsdC5X
+KQpxPWwuYT0wCmwuYj0hMAphLksoMCxuZXcgUC50aShsLHIpKQppZighbC5iKXJldHVybiExCnA9bS5j
+CnAuYSs9InsiCmZvcihvPSciJztxPHM7cSs9MixvPScsIicpe3AuYSs9bwptLnZwKEguaChyW3FdKSkK
+cC5hKz0nIjonCm49cSsxCmlmKG4+PXMpcmV0dXJuIEguT0gocixuKQptLmlVKHJbbl0pfXAuYSs9In0i
+CnJldHVybiEwfX0KUC50aS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYodHlw
+ZW9mIGEhPSJzdHJpbmciKXRoaXMuYS5iPSExCnM9dGhpcy5iCnI9dGhpcy5hCkMuTm0uWTUocyxyLmEr
+KyxhKQpDLk5tLlk1KHMsci5hKyssYil9LAokUzoxMH0KUC50dS5wcm90b3R5cGU9ewpnVks6ZnVuY3Rp
+b24oKXt2YXIgcz10aGlzLmMuYQpyZXR1cm4gcy5jaGFyQ29kZUF0KDApPT0wP3M6c319ClAudTUucHJv
+dG90eXBlPXsKZ1pFOmZ1bmN0aW9uKCl7cmV0dXJuIEMuUWt9fQpQLkUzLnByb3RvdHlwZT17CldKOmZ1
+bmN0aW9uKGEpe3ZhciBzLHIscSxwPVAuakIoMCxudWxsLGEubGVuZ3RoKSxvPXAtMAppZihvPT09MCly
+ZXR1cm4gbmV3IFVpbnQ4QXJyYXkoMCkKcz1vKjMKcj1uZXcgVWludDhBcnJheShzKQpxPW5ldyBQLlJ3
+KHIpCmlmKHEuR3goYSwwLHApIT09cCl7Si5hNihhLHAtMSkKcS5STygpfXJldHVybiBuZXcgVWludDhB
+cnJheShyLnN1YmFycmF5KDAsSC5yTSgwLHEuYixzKSkpfX0KUC5Sdy5wcm90b3R5cGU9ewpSTzpmdW5j
+dGlvbigpe3ZhciBzPXRoaXMscj1zLmMscT1zLmIscD1zLmI9cSsxLG89ci5sZW5ndGgKaWYocT49byly
+ZXR1cm4gSC5PSChyLHEpCnJbcV09MjM5CnE9cy5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkK
+cltwXT0xOTEKcy5iPXErMQppZihxPj1vKXJldHVybiBILk9IKHIscSkKcltxXT0xODl9LApPNjpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj10aGlzCmlmKChiJjY0NTEyKT09PTU2MzIwKXtzPTY1NTM2
+KygoYSYxMDIzKTw8MTApfGImMTAyMwpyPW4uYwpxPW4uYgpwPW4uYj1xKzEKbz1yLmxlbmd0aAppZihx
+Pj1vKXJldHVybiBILk9IKHIscSkKcltxXT1zPj4+MTh8MjQwCnE9bi5iPXArMQppZihwPj1vKXJldHVy
+biBILk9IKHIscCkKcltwXT1zPj4+MTImNjN8MTI4CnA9bi5iPXErMQppZihxPj1vKXJldHVybiBILk9I
+KHIscSkKcltxXT1zPj4+NiY2M3wxMjgKbi5iPXArMQppZihwPj1vKXJldHVybiBILk9IKHIscCkKcltw
+XT1zJjYzfDEyOApyZXR1cm4hMH1lbHNle24uUk8oKQpyZXR1cm4hMX19LApHeDpmdW5jdGlvbihhLGIs
+Yyl7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzCmlmKGIhPT1jJiYoQy54Qi5PMihhLGMtMSkmNjQ1MTIp
+PT09NTUyOTYpLS1jCmZvcihzPWwuYyxyPXMubGVuZ3RoLHE9YjtxPGM7KytxKXtwPUMueEIuVyhhLHEp
+CmlmKHA8PTEyNyl7bz1sLmIKaWYobz49cilicmVhawpsLmI9bysxCnNbb109cH1lbHNle289cCY2NDUx
+MgppZihvPT09NTUyOTYpe2lmKGwuYis0PnIpYnJlYWsKbj1xKzEKaWYobC5PNihwLEMueEIuVyhhLG4p
+KSlxPW59ZWxzZSBpZihvPT09NTYzMjApe2lmKGwuYiszPnIpYnJlYWsKbC5STygpfWVsc2UgaWYocDw9
+MjA0Nyl7bz1sLmIKbT1vKzEKaWYobT49cilicmVhawpsLmI9bQppZihvPj1yKXJldHVybiBILk9IKHMs
+bykKc1tvXT1wPj4+NnwxOTIKbC5iPW0rMQpzW21dPXAmNjN8MTI4fWVsc2V7bz1sLmIKaWYobysyPj1y
+KWJyZWFrCm09bC5iPW8rMQppZihvPj1yKXJldHVybiBILk9IKHMsbykKc1tvXT1wPj4+MTJ8MjI0Cm89
+bC5iPW0rMQppZihtPj1yKXJldHVybiBILk9IKHMsbSkKc1ttXT1wPj4+NiY2M3wxMjgKbC5iPW8rMQpp
+ZihvPj1yKXJldHVybiBILk9IKHMsbykKc1tvXT1wJjYzfDEyOH19fXJldHVybiBxfX0KUC5HWS5wcm90
+b3R5cGU9ewpXSjpmdW5jdGlvbihhKXt2YXIgcyxyCnQuTC5hKGEpCnM9dGhpcy5hCnI9UC5reShzLGEs
+MCxudWxsKQppZihyIT1udWxsKXJldHVybiByCnJldHVybiBuZXcgUC5ieihzKS5OZShhLDAsbnVsbCwh
+MCl9fQpQLmJ6LnByb3RvdHlwZT17Ck5lOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscSxwLG8sbj10
+aGlzCnQuTC5hKGEpCnM9UC5qQihiLGMsSi5IbShhKSkKaWYoYj09PXMpcmV0dXJuIiIKcj1QLmp5KGEs
+YixzKQpxPW4uaE8ociwwLHMtYiwhMCkKcD1uLmIKaWYoKHAmMSkhPT0wKXtvPVAuajQocCkKbi5iPTAK
+dGhyb3cgSC5iKFAucnIobyxhLGIrbi5jKSl9cmV0dXJuIHF9LApoTzpmdW5jdGlvbihhLGIsYyxkKXt2
+YXIgcyxyLHE9dGhpcwppZihjLWI+MTAwMCl7cz1DLmpuLkJVKGIrYywyKQpyPXEuaE8oYSxiLHMsITEp
+CmlmKChxLmImMSkhPT0wKXJldHVybiByCnJldHVybiByK3EuaE8oYSxzLGMsZCl9cmV0dXJuIHEuRWgo
+YSxiLGMsZCl9LApFaDpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4sbSxsLGs9dGhpcyxq
+PTY1NTMzLGk9ay5iLGg9ay5jLGc9bmV3IFAuUm4oIiIpLGY9YisxLGU9YS5sZW5ndGgKaWYoYjwwfHxi
+Pj1lKXJldHVybiBILk9IKGEsYikKcz1hW2JdCiRsYWJlbDAkMDpmb3Iocj1rLmE7ITA7KXtmb3IoOyEw
+O2Y9byl7cT1DLnhCLlcoIkFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
 QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB
-QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBRkZGRkZGRkZGRkZGRkZGRkdHR0dHR0dHR0dHR0dHR0dI
-SEhISEhISEhISEhISEhISEhISEhISEhISEhJSEhISkVFQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJC
-QkJCS0NDQ0NDQ0NDQ0NDQ0RDTE9OTk5NRUVFRUVFRUVFRUUiLHMpJjMxCmg9aTw9MzI/cyY2MTY5ND4+
-PnE6KHMmNjN8aDw8Nik+Pj4wCmk9Qy54Qi5XKCIgXHgwMDA6WEVDQ0NDQ046bERiIFx4MDAwOlhFQ0ND
-Q0NOdmxEYiBceDAwMDpYRUNDQ0NDTjpsRGIgQUFBQUFceDAwXHgwMFx4MDBceDAwXHgwMEFBQUFBMDAw
-MDBBQUFBQTo6Ojo6QUFBQUFHRzAwMEFBQUFBMDBLS0tBQUFBQUc6Ojo6QUFBQUE6SUlJSUFBQUFBMDAw
-XHg4MDBBQUFBQVx4MDBceDAwXHgwMFx4MDAgQUFBQUEiLGkrcSkKaWYoaT09PTApe2cuYSs9SC5Mdyho
-KQppZihmPT09YylicmVhayAkbGFiZWwwJDAKYnJlYWt9ZWxzZSBpZigoaSYxKSE9PTApe2lmKHIpc3dp
-dGNoKGkpe2Nhc2UgNjk6Y2FzZSA2NzpnLmErPUguTHcoaikKYnJlYWsKY2FzZSA2NTpnLmErPUguTHco
-aik7LS1mCmJyZWFrCmRlZmF1bHQ6cD1nLmErPUguTHcoaikKZy5hPXArSC5MdyhqKQpicmVha31lbHNl
-e2suYj1pCmsuYz1mLTEKcmV0dXJuIiJ9aT0wfWlmKGY9PT1jKWJyZWFrICRsYWJlbDAkMApvPWYrMQpp
-ZihmPDB8fGY+PWUpcmV0dXJuIEguT0goYSxmKQpzPWFbZl19bz1mKzEKaWYoZjwwfHxmPj1lKXJldHVy
-biBILk9IKGEsZikKcz1hW2ZdCmlmKHM8MTI4KXt3aGlsZSghMCl7aWYoIShvPGMpKXtuPWMKYnJlYWt9
-bT1vKzEKaWYobzwwfHxvPj1lKXJldHVybiBILk9IKGEsbykKcz1hW29dCmlmKHM+PTEyOCl7bj1tLTEK
-bz1tCmJyZWFrfW89bX1pZihuLWY8MjApZm9yKGw9ZjtsPG47KytsKXtpZihsPj1lKXJldHVybiBILk9I
-KGEsbCkKZy5hKz1ILkx3KGFbbF0pfWVsc2UgZy5hKz1QLkhNKGEsZixuKQppZihuPT09YylicmVhayAk
-bGFiZWwwJDAKZj1vfWVsc2UgZj1vfWlmKGQmJmk+MzIpaWYocilnLmErPUguTHcoaikKZWxzZXtrLmI9
-NzcKay5jPWMKcmV0dXJuIiJ9ay5iPWkKay5jPWgKZT1nLmEKcmV0dXJuIGUuY2hhckNvZGVBdCgwKT09
-MD9lOmV9fQpQLldGLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxCnQuZm8uYShh
-KQpzPXRoaXMuYgpyPXRoaXMuYQpzLmErPXIuYQpxPXMuYSs9SC5FaihhLmEpCnMuYT1xKyI6ICIKcy5h
-Kz1QLnAoYikKci5hPSIsICJ9LAokUzo0Mn0KUC5pUC5wcm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIp
-e2lmKGI9PW51bGwpcmV0dXJuITEKcmV0dXJuIGIgaW5zdGFuY2VvZiBQLmlQJiZ0aGlzLmE9PT1iLmEm
-JiEwfSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4oc15DLmpuLndHKHMsMzApKSYx
-MDczNzQxODIzfSwKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9UC5HcShILnRKKHMpKSxxPVAuaDAo
-SC5OUyhzKSkscD1QLmgwKEguakEocykpLG89UC5oMChILklYKHMpKSxuPVAuaDAoSC5jaChzKSksbT1Q
-LmgwKEguSmQocykpLGw9UC5WeChILm8xKHMpKSxrPXIrIi0iK3ErIi0iK3ArIiAiK28rIjoiK24rIjoi
-K20rIi4iK2wKcmV0dXJuIGt9fQpQLlhTLnByb3RvdHlwZT17CmdJSTpmdW5jdGlvbigpe3JldHVybiBI
-LnRzKHRoaXMuJHRocm93bkpzRXJyb3IpfX0KUC5DNi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3Zh
-ciBzPXRoaXMuYQppZihzIT1udWxsKXJldHVybiJBc3NlcnRpb24gZmFpbGVkOiAiK1AucChzKQpyZXR1
-cm4iQXNzZXJ0aW9uIGZhaWxlZCJ9fQpQLkV6LnByb3RvdHlwZT17fQpQLkYucHJvdG90eXBlPXsKdzpm
-dW5jdGlvbihhKXtyZXR1cm4iVGhyb3cgb2YgbnVsbC4ifX0KUC51LnByb3RvdHlwZT17CmdaOmZ1bmN0
-aW9uKCl7cmV0dXJuIkludmFsaWQgYXJndW1lbnQiKyghdGhpcy5hPyIocykiOiIiKX0sCmd1OmZ1bmN0
-aW9uKCl7cmV0dXJuIiJ9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9cS5jLG89cD09bnVs
-bD8iIjoiICgiK3ArIikiLG49cS5kLG09bj09bnVsbD8iIjoiOiAiK0guRWoobiksbD1xLmdaKCkrbytt
-CmlmKCFxLmEpcmV0dXJuIGwKcz1xLmd1KCkKcj1QLnAocS5iKQpyZXR1cm4gbCtzKyI6ICIrcn19ClAu
-YkoucHJvdG90eXBlPXsKZ1o6ZnVuY3Rpb24oKXtyZXR1cm4iUmFuZ2VFcnJvciJ9LApndTpmdW5jdGlv
-bigpe3ZhciBzLHI9dGhpcy5lLHE9dGhpcy5mCmlmKHI9PW51bGwpcz1xIT1udWxsPyI6IE5vdCBsZXNz
-IHRoYW4gb3IgZXF1YWwgdG8gIitILkVqKHEpOiIiCmVsc2UgaWYocT09bnVsbClzPSI6IE5vdCBncmVh
-dGVyIHRoYW4gb3IgZXF1YWwgdG8gIitILkVqKHIpCmVsc2UgaWYocT5yKXM9IjogTm90IGluIGluY2x1
-c2l2ZSByYW5nZSAiK0guRWoocikrIi4uIitILkVqKHEpCmVsc2Ugcz1xPHI/IjogVmFsaWQgdmFsdWUg
-cmFuZ2UgaXMgZW1wdHkiOiI6IE9ubHkgdmFsaWQgdmFsdWUgaXMgIitILkVqKHIpCnJldHVybiBzfX0K
-UC5lWS5wcm90b3R5cGU9ewpnWjpmdW5jdGlvbigpe3JldHVybiJSYW5nZUVycm9yIn0sCmd1OmZ1bmN0
-aW9uKCl7dmFyIHMscj1ILnVQKHRoaXMuYikKaWYodHlwZW9mIHIhPT0ibnVtYmVyIilyZXR1cm4gci5K
-KCkKaWYocjwwKXJldHVybiI6IGluZGV4IG11c3Qgbm90IGJlIG5lZ2F0aXZlIgpzPXRoaXMuZgppZihz
-PT09MClyZXR1cm4iOiBubyBpbmRpY2VzIGFyZSB2YWxpZCIKcmV0dXJuIjogaW5kZXggc2hvdWxkIGJl
-IGxlc3MgdGhhbiAiK0guRWoocyl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5mfX0KUC5tcC5w
-cm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsaz10aGlzLGo9e30saT1u
-ZXcgUC5SbigiIikKai5hPSIiCnM9ay5jCmZvcihyPXMubGVuZ3RoLHE9MCxwPSIiLG89IiI7cTxyOysr
-cSxvPSIsICIpe249c1txXQppLmE9cCtvCnA9aS5hKz1QLnAobikKai5hPSIsICJ9ay5kLksoMCxuZXcg
-UC5XRihqLGkpKQptPVAucChrLmEpCmw9aS53KDApCnI9Ik5vU3VjaE1ldGhvZEVycm9yOiBtZXRob2Qg
-bm90IGZvdW5kOiAnIitILkVqKGsuYi5hKSsiJ1xuUmVjZWl2ZXI6ICIrbSsiXG5Bcmd1bWVudHM6IFsi
-K2wrIl0iCnJldHVybiByfX0KUC51Yi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJVbnN1
-cHBvcnRlZCBvcGVyYXRpb246ICIrdGhpcy5hfX0KUC5kcy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEp
-e3ZhciBzPXRoaXMuYQpyZXR1cm4gcyE9bnVsbD8iVW5pbXBsZW1lbnRlZEVycm9yOiAiK3M6IlVuaW1w
-bGVtZW50ZWRFcnJvciJ9fQpQLmxqLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkJhZCBz
-dGF0ZTogIit0aGlzLmF9fQpQLlVWLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5h
-CmlmKHM9PW51bGwpcmV0dXJuIkNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uIGR1cmluZyBpdGVyYXRpb24u
-IgpyZXR1cm4iQ29uY3VycmVudCBtb2RpZmljYXRpb24gZHVyaW5nIGl0ZXJhdGlvbjogIitQLnAocykr
-Ii4ifX0KUC5rNS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJPdXQgb2YgTWVtb3J5In0s
-CmdJSTpmdW5jdGlvbigpe3JldHVybiBudWxsfSwKJGlYUzoxfQpQLktZLnByb3RvdHlwZT17Cnc6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIlN0YWNrIE92ZXJmbG93In0sCmdJSTpmdW5jdGlvbigpe3JldHVybiBudWxs
-fSwKJGlYUzoxfQpQLmMucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJu
-IHM9PW51bGw/IlJlYWRpbmcgc3RhdGljIHZhcmlhYmxlIGR1cmluZyBpdHMgaW5pdGlhbGl6YXRpb24i
-OiJSZWFkaW5nIHN0YXRpYyB2YXJpYWJsZSAnIitzKyInIGR1cmluZyBpdHMgaW5pdGlhbGl6YXRpb24i
-fX0KUC5DRC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJFeGNlcHRpb246ICIrdGhpcy5h
-fSwKJGlSejoxfQpQLmFFLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0s
-bCxrLGosaSxoLGc9dGhpcy5hLGY9ZyE9bnVsbCYmIiIhPT1nPyJGb3JtYXRFeGNlcHRpb246ICIrSC5F
-aihnKToiRm9ybWF0RXhjZXB0aW9uIixlPXRoaXMuYyxkPXRoaXMuYgppZih0eXBlb2YgZD09InN0cmlu
-ZyIpe2lmKGUhPW51bGwpcz1lPDB8fGU+ZC5sZW5ndGgKZWxzZSBzPSExCmlmKHMpZT1udWxsCmlmKGU9
-PW51bGwpe2lmKGQubGVuZ3RoPjc4KWQ9Qy54Qi5OaihkLDAsNzUpKyIuLi4iCnJldHVybiBmKyJcbiIr
-ZH1mb3Iocj0xLHE9MCxwPSExLG89MDtvPGU7KytvKXtuPUMueEIuVyhkLG8pCmlmKG49PT0xMCl7aWYo
-cSE9PW98fCFwKSsrcgpxPW8rMQpwPSExfWVsc2UgaWYobj09PTEzKXsrK3IKcT1vKzEKcD0hMH19Zj1y
-PjE/ZisoIiAoYXQgbGluZSAiK3IrIiwgY2hhcmFjdGVyICIrKGUtcSsxKSsiKVxuIik6ZisoIiAoYXQg
-Y2hhcmFjdGVyICIrKGUrMSkrIilcbiIpCm09ZC5sZW5ndGgKZm9yKG89ZTtvPG07KytvKXtuPUMueEIu
-TzIoZCxvKQppZihuPT09MTB8fG49PT0xMyl7bT1vCmJyZWFrfX1pZihtLXE+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
-IHRoaXMuJDIoYSxudWxsKX0sCiRTOjQ5fQpQLkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7
-dmFyIHMKaWYoYi1hPjQpdGhpcy5hLiQyKCJhbiBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFpbiBhIG1h
-eGltdW0gb2YgNCBoZXggZGlnaXRzIixhKQpzPVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwxNikKaWYo
-czwwfHxzPjY1NTM1KXRoaXMuYS4kMigiZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIG9mIGAw
-eDAuLjB4RkZGRmAiLGEpCnJldHVybiBzfSwKJFM6NTF9ClAuRG4ucHJvdG90eXBlPXsKZ25EOmZ1bmN0
-aW9uKCl7dmFyIHMscixxLHAsbz10aGlzCmlmKCFvLnkpe3M9by5hCnI9cy5sZW5ndGghPT0wP3MrIjoi
-OiIiCnE9by5jCnA9cT09bnVsbAppZighcHx8cz09PSJmaWxlIil7cz1yKyIvLyIKcj1vLmIKaWYoci5s
-ZW5ndGghPT0wKXM9cytyKyJAIgppZighcClzKz1xCnI9by5kCmlmKHIhPW51bGwpcz1zKyI6IitILkVq
-KHIpfWVsc2Ugcz1yCnMrPW8uZQpyPW8uZgppZihyIT1udWxsKXM9cysiPyIrcgpyPW8ucgppZihyIT1u
-dWxsKXM9cysiIyIrcgppZihvLnkpdGhyb3cgSC5iKEguR1EoIl90ZXh0IikpCm8ueD1zLmNoYXJDb2Rl
-QXQoMCk9PTA/czpzCm8ueT0hMH1yZXR1cm4gby54fSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRo
-aXMKaWYoIXEuUSl7cz1xLmUKaWYocy5sZW5ndGghPT0wJiZDLnhCLlcocywwKT09PTQ3KXM9Qy54Qi55
-bihzLDEpCnI9cy5sZW5ndGg9PT0wP0MueEQ6UC5BRihuZXcgSC5sSihILlZNKHMuc3BsaXQoIi8iKSx0
-LnMpLHQuZE8uYShQLlBIKCkpLHQuZG8pLHQuTikKaWYocS5RKXRocm93IEguYihILkdRKCJwYXRoU2Vn
-bWVudHMiKSkKcS5zS3AocikKcS5RPSEwfXJldHVybiBxLnp9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMs
-cj10aGlzCmlmKCFyLmN4KXtzPUouaGYoci5nbkQoKSkKaWYoci5jeCl0aHJvdyBILmIoSC5HUSgiaGFz
-aENvZGUiKSkKci5jaD1zCnIuY3g9ITB9cmV0dXJuIHIuY2h9LApnaFk6ZnVuY3Rpb24oKXt2YXIgcyxy
-PXRoaXMKaWYoIXIuZGIpe3M9UC5XWChyLmd0UCgpKQppZihyLmRiKXRocm93IEguYihILkdRKCJxdWVy
-eVBhcmFtZXRlcnMiKSkKci5zTk0obmV3IFAuR2oocyx0LmR3KSkKci5kYj0hMH1yZXR1cm4gci5jeX0s
-CmdrdTpmdW5jdGlvbigpe3JldHVybiB0aGlzLmJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5j
-CmlmKHM9PW51bGwpcmV0dXJuIiIKaWYoQy54Qi5uQyhzLCJbIikpcmV0dXJuIEMueEIuTmoocywxLHMu
-bGVuZ3RoLTEpCnJldHVybiBzfSwKZ3RwOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZApyZXR1cm4gcz09
-bnVsbD9QLndLKHRoaXMuYSk6c30sCmd0UDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuZgpyZXR1cm4gcz09
-bnVsbD8iIjpzfSwKZ0thOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5yCnJldHVybiBzPT1udWxsPyIiOnN9
-LApubTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqPXRoaXMKdC5jOS5hKGIpCnM9
-ai5hCnI9cz09PSJmaWxlIgpxPWouYgpwPWouZApvPWouYwppZighKG8hPW51bGwpKW89cS5sZW5ndGgh
-PT0wfHxwIT1udWxsfHxyPyIiOm51bGwKbj1qLmUKaWYoIXIpbT1vIT1udWxsJiZuLmxlbmd0aCE9PTAK
-ZWxzZSBtPSEwCmlmKG0mJiFDLnhCLm5DKG4sIi8iKSluPSIvIituCmw9bgprPVAubGUobnVsbCwwLDAs
-YikKcmV0dXJuIG5ldyBQLkRuKHMscSxvLHAsbCxrLGoucil9LApKaDpmdW5jdGlvbihhLGIpe3ZhciBz
-LHIscSxwLG8sbgpmb3Iocz0wLHI9MDtDLnhCLlFpKGIsIi4uLyIscik7KXtyKz0zOysrc31xPUMueEIu
-Y24oYSwiLyIpCndoaWxlKCEwKXtpZighKHE+MCYmcz4wKSlicmVhawpwPUMueEIuUGsoYSwiLyIscS0x
-KQppZihwPDApYnJlYWsKbz1xLXAKbj1vIT09MgppZighbnx8bz09PTMpaWYoQy54Qi5PMihhLHArMSk9
-PT00NiluPSFufHxDLnhCLk8yKGEscCsyKT09PTQ2CmVsc2Ugbj0hMQplbHNlIG49ITEKaWYobilicmVh
-azstLXMKcT1wfXJldHVybiBDLnhCLmk3KGEscSsxLG51bGwsQy54Qi55bihiLHItMypzKSl9LApaSTpm
-dW5jdGlvbihhKXtyZXR1cm4gdGhpcy5tUyhQLmhLKGEpKX0sCm1TOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
-cSxwLG8sbixtLGwsayxqPXRoaXMsaT1udWxsCmlmKGEuZ0ZpKCkubGVuZ3RoIT09MCl7cz1hLmdGaSgp
-CmlmKGEuZ2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9YS5neEEoKT9hLmd0cChhKTppfWVsc2V7
-cD1pCnE9cApyPSIifW89UC54ZShhLmdJaShhKSkKbj1hLmdRRCgpP2EuZ3RQKCk6aX1lbHNle3M9ai5h
-CmlmKGEuZ2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9UC53QihhLmd4QSgpP2EuZ3RwKGEpOmks
-cykKbz1QLnhlKGEuZ0lpKGEpKQpuPWEuZ1FEKCk/YS5ndFAoKTppfWVsc2V7cj1qLmIKcT1qLmMKcD1q
-LmQKaWYoYS5nSWkoYSk9PT0iIil7bz1qLmUKbj1hLmdRRCgpP2EuZ3RQKCk6ai5mfWVsc2V7aWYoYS5n
-dFQoKSlvPVAueGUoYS5nSWkoYSkpCmVsc2V7bT1qLmUKaWYobS5sZW5ndGg9PT0wKWlmKHE9PW51bGwp
-bz1zLmxlbmd0aD09PTA/YS5nSWkoYSk6UC54ZShhLmdJaShhKSkKZWxzZSBvPVAueGUoIi8iK2EuZ0lp
-KGEpKQplbHNle2w9ai5KaChtLGEuZ0lpKGEpKQprPXMubGVuZ3RoPT09MAppZigha3x8cSE9bnVsbHx8
-Qy54Qi5uQyhtLCIvIikpbz1QLnhlKGwpCmVsc2Ugbz1QLndGKGwsIWt8fHEhPW51bGwpfX1uPWEuZ1FE
-KCk/YS5ndFAoKTppfX19cmV0dXJuIG5ldyBQLkRuKHMscixxLHAsbyxuLGEuZ1o4KCk/YS5nS2EoKTpp
-KX0sCmdjajpmdW5jdGlvbigpe3JldHVybiB0aGlzLmMhPW51bGx9LApneEE6ZnVuY3Rpb24oKXtyZXR1
-cm4gdGhpcy5kIT1udWxsfSwKZ1FEOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZiE9bnVsbH0sCmdaODpm
-dW5jdGlvbigpe3JldHVybiB0aGlzLnIhPW51bGx9LApndFQ6ZnVuY3Rpb24oKXtyZXR1cm4gQy54Qi5u
-Qyh0aGlzLmUsIi8iKX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5hCmlmKHEhPT0iIiYm
-cSE9PSJmaWxlIil0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBh
-ICIrcSsiIFVSSSIpKQppZihyLmd0UCgpIT09IiIpdGhyb3cgSC5iKFAuTDQodS5pKSkKaWYoci5nS2Eo
-KSE9PSIiKXRocm93IEguYihQLkw0KHUubCkpCnE9JC53USgpCmlmKEgub1QocSkpcT1QLm1uKHIpCmVs
-c2V7aWYoci5jIT1udWxsJiZyLmdKZihyKSE9PSIiKUgudihQLkw0KHUuaikpCnM9ci5nRmooKQpQLmtF
-KHMsITEpCnE9UC52ZyhDLnhCLm5DKHIuZSwiLyIpPyIvIjoiIixzLCIvIikKcT1xLmNoYXJDb2RlQXQo
-MCk9PTA/cTpxfXJldHVybiBxfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nbkQoKX0sCkROOmZ1
-bmN0aW9uKGEsYil7dmFyIHM9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHM9PT1iKXJldHVybiEw
-CnJldHVybiB0LmRELmIoYikmJnMuYT09PWIuZ0ZpKCkmJnMuYyE9bnVsbD09PWIuZ2NqKCkmJnMuYj09
-PWIuZ2t1KCkmJnMuZ0pmKHMpPT09Yi5nSmYoYikmJnMuZ3RwKHMpPT09Yi5ndHAoYikmJnMuZT09PWIu
-Z0lpKGIpJiZzLmYhPW51bGw9PT1iLmdRRCgpJiZzLmd0UCgpPT09Yi5ndFAoKSYmcy5yIT1udWxsPT09
-Yi5nWjgoKSYmcy5nS2EoKT09PWIuZ0thKCl9LApzS3A6ZnVuY3Rpb24oYSl7dGhpcy56PXQuYmsuYShh
-KX0sCnNOTTpmdW5jdGlvbihhKXt0aGlzLmN5PXQuY1ouYShhKX0sCiRpaUQ6MSwKZ0ZpOmZ1bmN0aW9u
-KCl7cmV0dXJuIHRoaXMuYX0sCmdJaTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5lfX0KUC5SWi5wcm90
-b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gUC5lUChDLlpKLEguaChhKSxDLnhNLCExKX0sCiRT
-OjV9ClAuTUUucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmIscj10aGlzLmEK
-cy5hKz1yLmEKci5hPSImIgpyPXMuYSs9SC5FaihQLmVQKEMuRjMsYSxDLnhNLCEwKSkKaWYoYiE9bnVs
-bCYmYi5sZW5ndGghPT0wKXtzLmE9cisiPSIKcy5hKz1ILkVqKFAuZVAoQy5GMyxiLEMueE0sITApKX19
-LAokUzoyMn0KUC55NS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC5oKGEpCmlm
-KGI9PW51bGx8fHR5cGVvZiBiPT0ic3RyaW5nIil0aGlzLmEuJDIoYSxILmsoYikpCmVsc2UgZm9yKHM9
-Si5JVCh0LnUuYShiKSkscj10aGlzLmE7cy5GKCk7KXIuJDIoYSxILmgocy5nbCgpKSl9LAokUzoxMn0K
-UC5QRS5wcm90b3R5cGU9ewpnbFI6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1udWxsLG09
-by5jCmlmKG09PW51bGwpe209by5iCmlmKDA+PW0ubGVuZ3RoKXJldHVybiBILk9IKG0sMCkKcz1vLmEK
-bT1tWzBdKzEKcj1DLnhCLlhVKHMsIj8iLG0pCnE9cy5sZW5ndGgKaWYocj49MCl7cD1QLlBJKHMscisx
-LHEsQy5WQywhMSkKcT1yfWVsc2UgcD1uCm09by5jPW5ldyBQLnFlKCJkYXRhIiwiIixuLG4sUC5QSShz
-LG0scSxDLldkLCExKSxwLG4pfXJldHVybiBtfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuYgpp
-ZigwPj1yLmxlbmd0aClyZXR1cm4gSC5PSChyLDApCnM9dGhpcy5hCnJldHVybiByWzBdPT09LTE/ImRh
-dGE6IitzOnN9fQpQLnlJLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5hCmlm
-KGE+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYSkKcz1zW2FdCkMuTkEuZHUocywwLDk2LGIpCnJldHVy
-biBzfSwKJFM6MjN9ClAuYzYucHJvdG90eXBlPXsKJDM6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpm
-b3Iocz1iLmxlbmd0aCxyPTA7cjxzOysrcil7cT1DLnhCLlcoYixyKV45NgppZihxPj05NilyZXR1cm4g
-SC5PSChhLHEpCmFbcV09Y319LAokUzoxM30KUC5xZC5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIs
-Yyl7dmFyIHMscixxCmZvcihzPUMueEIuVyhiLDApLHI9Qy54Qi5XKGIsMSk7czw9cjsrK3Mpe3E9KHNe
-OTYpPj4+MAppZihxPj05NilyZXR1cm4gSC5PSChhLHEpCmFbcV09Y319LAokUzoxM30KUC5VZi5wcm90
-b3R5cGU9ewpnY2o6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5jPjB9LApneEE6ZnVuY3Rpb24oKXtyZXR1
-cm4gdGhpcy5jPjAmJnRoaXMuZCsxPHRoaXMuZX0sCmdRRDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmY8
-dGhpcy5yfSwKZ1o4OmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMucjx0aGlzLmEubGVuZ3RofSwKZ053OmZ1
-bmN0aW9uKCl7cmV0dXJuIHRoaXMuYj09PTQmJkMueEIubkModGhpcy5hLCJmaWxlIil9LApnV1o6ZnVu
-Y3Rpb24oKXtyZXR1cm4gdGhpcy5iPT09NCYmQy54Qi5uQyh0aGlzLmEsImh0dHAiKX0sCmdSZTpmdW5j
-dGlvbigpe3JldHVybiB0aGlzLmI9PT01JiZDLnhCLm5DKHRoaXMuYSwiaHR0cHMiKX0sCmd0VDpmdW5j
-dGlvbigpe3JldHVybiBDLnhCLlFpKHRoaXMuYSwiLyIsdGhpcy5lKX0sCmdGaTpmdW5jdGlvbigpe3Zh
-ciBzPXRoaXMueApyZXR1cm4gcz09bnVsbD90aGlzLng9dGhpcy5VMigpOnN9LApVMjpmdW5jdGlvbigp
-e3ZhciBzPXRoaXMscj1zLmIKaWYocjw9MClyZXR1cm4iIgppZihzLmdXWigpKXJldHVybiJodHRwIgpp
-ZihzLmdSZSgpKXJldHVybiJodHRwcyIKaWYocy5nTncoKSlyZXR1cm4iZmlsZSIKaWYocj09PTcmJkMu
-eEIubkMocy5hLCJwYWNrYWdlIikpcmV0dXJuInBhY2thZ2UiCnJldHVybiBDLnhCLk5qKHMuYSwwLHIp
-fSwKZ2t1OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5jLHI9dGhpcy5iKzMKcmV0dXJuIHM+cj9DLnhCLk5q
-KHRoaXMuYSxyLHMtMSk6IiJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCnJldHVybiBzPjA/
-Qy54Qi5Oaih0aGlzLmEscyx0aGlzLmQpOiIifSwKZ3RwOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMKaWYo
-cy5neEEoKSlyZXR1cm4gUC5RQShDLnhCLk5qKHMuYSxzLmQrMSxzLmUpLG51bGwpCmlmKHMuZ1daKCkp
-cmV0dXJuIDgwCmlmKHMuZ1JlKCkpcmV0dXJuIDQ0MwpyZXR1cm4gMH0sCmdJaTpmdW5jdGlvbihhKXty
-ZXR1cm4gQy54Qi5Oaih0aGlzLmEsdGhpcy5lLHRoaXMuZil9LApndFA6ZnVuY3Rpb24oKXt2YXIgcz10
-aGlzLmYscj10aGlzLnIKcmV0dXJuIHM8cj9DLnhCLk5qKHRoaXMuYSxzKzEscik6IiJ9LApnS2E6ZnVu
-Y3Rpb24oKXt2YXIgcz10aGlzLnIscj10aGlzLmEKcmV0dXJuIHM8ci5sZW5ndGg/Qy54Qi55bihyLHMr
-MSk6IiJ9LApnRmo6ZnVuY3Rpb24oKXt2YXIgcyxyLHE9dGhpcy5lLHA9dGhpcy5mLG89dGhpcy5hCmlm
-KEMueEIuUWkobywiLyIscSkpKytxCmlmKHE9PT1wKXJldHVybiBDLnhECnM9SC5WTShbXSx0LnMpCmZv
-cihyPXE7cjxwOysrcilpZihDLnhCLk8yKG8scik9PT00Nyl7Qy5ObS5pKHMsQy54Qi5OaihvLHEscikp
-CnE9cisxfUMuTm0uaShzLEMueEIuTmoobyxxLHApKQpyZXR1cm4gUC5BRihzLHQuTil9LApnaFk6ZnVu
-Y3Rpb24oKXtpZih0aGlzLmY+PXRoaXMucilyZXR1cm4gQy5DTQpyZXR1cm4gbmV3IFAuR2ooUC5XWCh0
-aGlzLmd0UCgpKSx0LmR3KX0sCmtYOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZCsxCnJldHVybiBzK2Eu
-bGVuZ3RoPT09dGhpcy5lJiZDLnhCLlFpKHRoaXMuYSxhLHMpfSwKTjk6ZnVuY3Rpb24oKXt2YXIgcz10
-aGlzLHI9cy5yLHE9cy5hCmlmKHI+PXEubGVuZ3RoKXJldHVybiBzCnJldHVybiBuZXcgUC5VZihDLnhC
-Lk5qKHEsMCxyKSxzLmIscy5jLHMuZCxzLmUscy5mLHIscy54KX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFy
-IHMscixxLHAsbyxuLG0sbCxrLGosaT10aGlzLGg9bnVsbAp0LmM5LmEoYikKcz1pLmdGaSgpCnI9cz09
-PSJmaWxlIgpxPWkuYwpwPXE+MD9DLnhCLk5qKGkuYSxpLmIrMyxxKToiIgpvPWkuZ3hBKCk/aS5ndHAo
-aSk6aApxPWkuYwppZihxPjApbj1DLnhCLk5qKGkuYSxxLGkuZCkKZWxzZSBuPXAubGVuZ3RoIT09MHx8
-byE9bnVsbHx8cj8iIjpoCnE9aS5hCm09Qy54Qi5OaihxLGkuZSxpLmYpCmlmKCFyKWw9biE9bnVsbCYm
-bS5sZW5ndGghPT0wCmVsc2UgbD0hMAppZihsJiYhQy54Qi5uQyhtLCIvIikpbT0iLyIrbQprPVAubGUo
-aCwwLDAsYikKbD1pLnIKaj1sPHEubGVuZ3RoP0MueEIueW4ocSxsKzEpOmgKcmV0dXJuIG5ldyBQLkRu
-KHMscCxuLG8sbSxrLGopfSwKWkk6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMubVMoUC5oSyhhKSl9LApt
-UzpmdW5jdGlvbihhKXtpZihhIGluc3RhbmNlb2YgUC5VZilyZXR1cm4gdGhpcy51MSh0aGlzLGEpCnJl
-dHVybiB0aGlzLnZzKCkubVMoYSl9LAp1MTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGws
-ayxqLGksaCxnPWIuYgppZihnPjApcmV0dXJuIGIKcz1iLmMKaWYocz4wKXtyPWEuYgppZihyPD0wKXJl
-dHVybiBiCmlmKGEuZ053KCkpcT1iLmUhPT1iLmYKZWxzZSBpZihhLmdXWigpKXE9IWIua1goIjgwIikK
-ZWxzZSBxPSFhLmdSZSgpfHwhYi5rWCgiNDQzIikKaWYocSl7cD1yKzEKcmV0dXJuIG5ldyBQLlVmKEMu
-eEIuTmooYS5hLDAscCkrQy54Qi55bihiLmEsZysxKSxyLHMrcCxiLmQrcCxiLmUrcCxiLmYrcCxiLnIr
-cCxhLngpfWVsc2UgcmV0dXJuIHRoaXMudnMoKS5tUyhiKX1vPWIuZQpnPWIuZgppZihvPT09Zyl7cz1i
-LnIKaWYoZzxzKXtyPWEuZgpwPXItZwpyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihhLmEsMCxyKStDLnhC
-LnluKGIuYSxnKSxhLmIsYS5jLGEuZCxhLmUsZytwLHMrcCxhLngpfWc9Yi5hCmlmKHM8Zy5sZW5ndGgp
-e3I9YS5yCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4oZyxzKSxhLmIsYS5j
-LGEuZCxhLmUsYS5mLHMrKHItcyksYS54KX1yZXR1cm4gYS5OOSgpfXM9Yi5hCmlmKEMueEIuUWkocywi
-LyIsbykpe3I9YS5lCnA9ci1vCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4o
-cyxvKSxhLmIsYS5jLGEuZCxyLGcrcCxiLnIrcCxhLngpfW49YS5lCm09YS5mCmlmKG49PT1tJiZhLmM+
-MCl7Zm9yKDtDLnhCLlFpKHMsIi4uLyIsbyk7KW8rPTMKcD1uLW8rMQpyZXR1cm4gbmV3IFAuVWYoQy54
-Qi5OaihhLmEsMCxuKSsiLyIrQy54Qi55bihzLG8pLGEuYixhLmMsYS5kLG4sZytwLGIucitwLGEueCl9
-bD1hLmEKZm9yKGs9bjtDLnhCLlFpKGwsIi4uLyIsayk7KWsrPTMKaj0wCndoaWxlKCEwKXtpPW8rMwpp
-ZighKGk8PWcmJkMueEIuUWkocywiLi4vIixvKSkpYnJlYWs7KytqCm89aX1mb3IoaD0iIjttPms7KXst
-LW0KaWYoQy54Qi5PMihsLG0pPT09NDcpe2lmKGo9PT0wKXtoPSIvIgpicmVha30tLWoKaD0iLyJ9fWlm
-KG09PT1rJiZhLmI8PTAmJiFDLnhCLlFpKGwsIi8iLG4pKXtvLT1qKjMKaD0iIn1wPW0tbytoLmxlbmd0
-aApyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihsLDAsbSkraCtDLnhCLnluKHMsbyksYS5iLGEuYyxhLmQs
-bixnK3AsYi5yK3AsYS54KX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHA9dGhpcwppZihwLmI+PTAm
-JiFwLmdOdygpKXRocm93IEguYihQLkw0KCJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEg
-IitwLmdGaSgpKyIgVVJJIikpCnM9cC5mCnI9cC5hCmlmKHM8ci5sZW5ndGgpe2lmKHM8cC5yKXRocm93
-IEguYihQLkw0KHUuaSkpCnRocm93IEguYihQLkw0KHUubCkpfXE9JC53USgpCmlmKEgub1QocSkpcz1Q
-Lm1uKHApCmVsc2V7aWYocC5jPHAuZClILnYoUC5MNCh1LmopKQpzPUMueEIuTmoocixwLmUscyl9cmV0
-dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy55CnJldHVybiBzPT1udWxsP3RoaXMueT1D
-LnhCLmdpTyh0aGlzLmEpOnN9LApETjpmdW5jdGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKaWYo
-dGhpcz09PWIpcmV0dXJuITAKcmV0dXJuIHQuZEQuYihiKSYmdGhpcy5hPT09Yi53KDApfSwKdnM6ZnVu
-Y3Rpb24oKXt2YXIgcz10aGlzLHI9bnVsbCxxPXMuZ0ZpKCkscD1zLmdrdSgpLG89cy5jPjA/cy5nSmYo
-cyk6cixuPXMuZ3hBKCk/cy5ndHAocyk6cixtPXMuYSxsPXMuZixrPUMueEIuTmoobSxzLmUsbCksaj1z
-LnIKbD1sPGo/cy5ndFAoKTpyCnJldHVybiBuZXcgUC5EbihxLHAsbyxuLGssbCxqPG0ubGVuZ3RoP3Mu
-Z0thKCk6cil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LAokaWlEOjF9ClAucWUucHJvdG90
-eXBlPXt9ClcucUUucHJvdG90eXBlPXt9ClcuR2gucHJvdG90eXBlPXsKc0xVOmZ1bmN0aW9uKGEsYil7
-YS5ocmVmPWJ9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9LAokaUdoOjF9ClcuZlkucHJv
-dG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0KVy5uQi5wcm90b3R5cGU9eyRp
-bkI6MX0KVy5Bei5wcm90b3R5cGU9eyRpQXo6MX0KVy5RUC5wcm90b3R5cGU9eyRpUVA6MX0KVy5ueC5w
-cm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLm9KLnByb3RvdHlwZT17
-CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19ClcuaWQucHJvdG90eXBlPXt9ClcuUUYucHJv
-dG90eXBlPXt9ClcuTmgucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0K
-Vy5hZS5wcm90b3R5cGU9ewpEYzpmdW5jdGlvbihhLGIpe3JldHVybiBhLmNyZWF0ZUhUTUxEb2N1bWVu
-dChiKX19ClcuSUIucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPWEubGVmdApyLnRvU3Ry
-aW5nCnI9IlJlY3RhbmdsZSAoIitILkVqKHIpKyIsICIKcz1hLnRvcApzLnRvU3RyaW5nCnM9citILkVq
-KHMpKyIpICIKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1zK0guRWoocikrIiB4ICIKcz1hLmhlaWdodApz
-LnRvU3RyaW5nCnJldHVybiByK0guRWoocyl9LApETjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoYj09
-bnVsbClyZXR1cm4hMQppZih0LnEuYihiKSl7cz1hLmxlZnQKcy50b1N0cmluZwpyPWIubGVmdApyLnRv
-U3RyaW5nCmlmKHM9PT1yKXtzPWEudG9wCnMudG9TdHJpbmcKcj1iLnRvcApyLnRvU3RyaW5nCmlmKHM9
-PT1yKXtzPWEud2lkdGgKcy50b1N0cmluZwpyPWIud2lkdGgKci50b1N0cmluZwppZihzPT09cil7cz1h
-LmhlaWdodApzLnRvU3RyaW5nCnI9Yi5oZWlnaHQKci50b1N0cmluZwpyPXM9PT1yCnM9cn1lbHNlIHM9
-ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITEKcmV0dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7
-dmFyIHMscixxLHA9YS5sZWZ0CnAudG9TdHJpbmcKcD1DLkNELmdpTyhwKQpzPWEudG9wCnMudG9TdHJp
-bmcKcz1DLkNELmdpTyhzKQpyPWEud2lkdGgKci50b1N0cmluZwpyPUMuQ0QuZ2lPKHIpCnE9YS5oZWln
-aHQKcS50b1N0cmluZwpyZXR1cm4gVy5yRShwLHMscixDLkNELmdpTyhxKSl9LAokaXRuOjF9Clcubjcu
-cHJvdG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy53ei5wcm90b3R5cGU9
-ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXt2YXIg
-cwpILnVQKGIpCnM9dGhpcy5hCmlmKGI8MHx8Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1
-cm4gdGhpcy4kdGkuYy5hKHNbYl0pfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuJHRpLmMuYShjKQp0
-aHJvdyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSBsaXN0IikpfX0KVy5jdi5wcm90b3R5cGU9ewpnUWc6
-ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLmk3KGEpfSwKZ246ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBX
-Lkk0KGEpfSwKc246ZnVuY3Rpb24oYSxiKXt2YXIgcwp0LlEuYShiKQpzPXRoaXMuZ24oYSkKcy5WMSgw
-KQpzLkZWKDAsYil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxvY2FsTmFtZX0sCkZGOmZ1bmN0aW9u
-KGEpe3ZhciBzPSEhYS5zY3JvbGxJbnRvVmlld0lmTmVlZGVkCmlmKHMpYS5zY3JvbGxJbnRvVmlld0lm
-TmVlZGVkKCkKZWxzZSBhLnNjcm9sbEludG9WaWV3KCl9LApuejpmdW5jdGlvbihhLGIsYyxkLGUpe3Zh
-ciBzLHI9dGhpcy5yNihhLGMsZCxlKQpzd2l0Y2goYi50b0xvd2VyQ2FzZSgpKXtjYXNlImJlZm9yZWJl
-Z2luIjpzPWEucGFyZW50Tm9kZQpzLnRvU3RyaW5nCkouRWgocyxyLGEpCmJyZWFrCmNhc2UiYWZ0ZXJi
-ZWdpbiI6cz1hLmNoaWxkTm9kZXMKdGhpcy5tSyhhLHIscy5sZW5ndGg+MD9zWzBdOm51bGwpCmJyZWFr
-CmNhc2UiYmVmb3JlZW5kIjphLmFwcGVuZENoaWxkKHIpCmJyZWFrCmNhc2UiYWZ0ZXJlbmQiOnM9YS5w
-YXJlbnROb2RlCnMudG9TdHJpbmcKSi5FaChzLHIsYS5uZXh0U2libGluZykKYnJlYWsKZGVmYXVsdDpI
-LnYoUC54WSgiSW52YWxpZCBwb3NpdGlvbiAiK2IpKX19LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIg
-cyxyLHEscAppZihjPT1udWxsKXtpZihkPT1udWxsKXtzPSQubHQKaWYocz09bnVsbCl7cz1ILlZNKFtd
-LHQudikKcj1uZXcgVy52RChzKQpDLk5tLmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJsKCkpCiQu
-bHQ9cgpkPXJ9ZWxzZSBkPXN9cz0kLkVVCmlmKHM9PW51bGwpe3M9bmV3IFcuS28oZCkKJC5FVT1zCmM9
-c31lbHNle3MuYT1kCmM9c319ZWxzZSBpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJ2YWxpZGF0b3Ig
-Y2FuIG9ubHkgYmUgcGFzc2VkIGlmIHRyZWVTYW5pdGl6ZXIgaXMgbnVsbCIpKQppZigkLnhvPT1udWxs
-KXtzPWRvY3VtZW50CnI9cy5pbXBsZW1lbnRhdGlvbgpyLnRvU3RyaW5nCnI9Qy5tSC5EYyhyLCIiKQok
-LnhvPXIKJC5CTz1yLmNyZWF0ZVJhbmdlKCkKcj0kLnhvLmNyZWF0ZUVsZW1lbnQoImJhc2UiKQp0LmNS
-LmEocikKcz1zLmJhc2VVUkkKcy50b1N0cmluZwpyLmhyZWY9cwokLnhvLmhlYWQuYXBwZW5kQ2hpbGQo
-cil9cz0kLnhvCmlmKHMuYm9keT09bnVsbCl7cj1zLmNyZWF0ZUVsZW1lbnQoImJvZHkiKQpDLkJaLnNY
-RyhzLHQucC5hKHIpKX1zPSQueG8KaWYodC5wLmIoYSkpe3M9cy5ib2R5CnMudG9TdHJpbmcKcT1zfWVs
-c2V7cy50b1N0cmluZwpxPXMuY3JlYXRlRWxlbWVudChhLnRhZ05hbWUpCiQueG8uYm9keS5hcHBlbmRD
-aGlsZChxKX1pZigiY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50IiBpbiB3aW5kb3cuUmFuZ2UucHJvdG90
-eXBlJiYhQy5ObS50ZyhDLlNxLGEudGFnTmFtZSkpeyQuQk8uc2VsZWN0Tm9kZUNvbnRlbnRzKHEpCnM9
-JC5CTwpzLnRvU3RyaW5nCnA9cy5jcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQoYj09bnVsbD8ibnVsbCI6
-Yil9ZWxzZXtKLndmKHEsYikKcD0kLnhvLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpmb3IoO3M9cS5m
-aXJzdENoaWxkLHMhPW51bGw7KXAuYXBwZW5kQ2hpbGQocyl9aWYocSE9PSQueG8uYm9keSlKLkx0KHEp
-CmMuUG4ocCkKZG9jdW1lbnQuYWRvcHROb2RlKHApCnJldHVybiBwfSwKQUg6ZnVuY3Rpb24oYSxiLGMp
-e3JldHVybiB0aGlzLnI2KGEsYixjLG51bGwpfSwKc2hmOmZ1bmN0aW9uKGEsYil7dGhpcy5ZQyhhLGIp
-fSwKcGs6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuc2E0KGEsbnVsbCkKYS5hcHBlbmRDaGlsZCh0aGlzLnI2
-KGEsYixudWxsLGMpKX0sCllDOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMucGsoYSxiLG51bGwpfSwK
-c1JOOmZ1bmN0aW9uKGEsYil7YS5pbm5lckhUTUw9Yn0sCmduczpmdW5jdGlvbihhKXtyZXR1cm4gYS50
-YWdOYW1lfSwKZ1ZsOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5ldShhLCJjbGljayIsITEsdC5rKX0s
-CiRpY3Y6MX0KVy5Ddi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5oLmIodC5BLmEo
-YSkpfSwKJFM6MjV9ClcuZWEucHJvdG90eXBlPXskaWVhOjF9ClcuRDAucHJvdG90eXBlPXsKT246ZnVu
-Y3Rpb24oYSxiLGMsZCl7dC5idy5hKGMpCmlmKGMhPW51bGwpdGhpcy52KGEsYixjLGQpfSwKQjpmdW5j
-dGlvbihhLGIsYyl7cmV0dXJuIHRoaXMuT24oYSxiLGMsbnVsbCl9LAp2OmZ1bmN0aW9uKGEsYixjLGQp
-e3JldHVybiBhLmFkZEV2ZW50TGlzdGVuZXIoYixILnRSKHQuYncuYShjKSwxKSxkKX0sCiRpRDA6MX0K
-Vy5oSC5wcm90b3R5cGU9eyRpaEg6MX0KVy5oNC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1
-cm4gYS5sZW5ndGh9fQpXLmJyLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0
-aH19ClcuVmIucHJvdG90eXBlPXsKc1hHOmZ1bmN0aW9uKGEsYil7YS5ib2R5PWJ9fQpXLmZKLnByb3Rv
-dHlwZT17CmVvOmZ1bmN0aW9uKGEsYixjLGQpe3JldHVybiBhLm9wZW4oYixjLCEwKX0sCiRpZko6MX0K
-Vy53YS5wcm90b3R5cGU9e30KVy5TZy5wcm90b3R5cGU9eyRpU2c6MX0KVy53Ny5wcm90b3R5cGU9ewpn
-RHI6ZnVuY3Rpb24oYSl7aWYoIm9yaWdpbiIgaW4gYSlyZXR1cm4gYS5vcmlnaW4KcmV0dXJuIEguRWoo
-YS5wcm90b2NvbCkrIi8vIitILkVqKGEuaG9zdCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmco
-YSl9LAokaXc3OjF9ClcuQWoucHJvdG90eXBlPXskaUFqOjF9ClcuZTcucHJvdG90eXBlPXsKZ3I4OmZ1
-bmN0aW9uKGEpe3ZhciBzPXRoaXMuYSxyPXMuY2hpbGROb2Rlcy5sZW5ndGgKaWYocj09PTApdGhyb3cg
-SC5iKFAuUFYoIk5vIGVsZW1lbnRzIikpCmlmKHI+MSl0aHJvdyBILmIoUC5QVigiTW9yZSB0aGFuIG9u
-ZSBlbGVtZW50IikpCnM9cy5maXJzdENoaWxkCnMudG9TdHJpbmcKcmV0dXJuIHN9LApGVjpmdW5jdGlv
-bihhLGIpe3ZhciBzLHIscSxwLG8KdC5laC5hKGIpCmlmKGIgaW5zdGFuY2VvZiBXLmU3KXtzPWIuYQpy
-PXRoaXMuYQppZihzIT09cilmb3IocT1zLmNoaWxkTm9kZXMubGVuZ3RoLHA9MDtwPHE7KytwKXtvPXMu
-Zmlyc3RDaGlsZApvLnRvU3RyaW5nCnIuYXBwZW5kQ2hpbGQobyl9cmV0dXJufWZvcihzPWIuZ20oYiks
-cj10aGlzLmE7cy5GKCk7KXIuYXBwZW5kQ2hpbGQocy5nbCgpKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt2
-YXIgcyxyCnQuQS5hKGMpCnM9dGhpcy5hCnI9cy5jaGlsZE5vZGVzCmlmKGI8MHx8Yj49ci5sZW5ndGgp
-cmV0dXJuIEguT0gocixiKQpzLnJlcGxhY2VDaGlsZChjLHJbYl0pfSwKZ206ZnVuY3Rpb24oYSl7dmFy
-IHM9dGhpcy5hLmNoaWxkTm9kZXMKcmV0dXJuIG5ldyBXLlc5KHMscy5sZW5ndGgsSC56KHMpLkMoIlc5
-PEdtLkU+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jaGlsZE5vZGVzLmxlbmd0aH0s
-CnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIpCnM9dGhpcy5hLmNoaWxkTm9kZXMKaWYoYjwwfHxi
-Pj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLGIpCnJldHVybiBzW2JdfX0KVy51SC5wcm90b3R5cGU9ewp3
-ZzpmdW5jdGlvbihhKXt2YXIgcz1hLnBhcmVudE5vZGUKaWYocyE9bnVsbClzLnJlbW92ZUNoaWxkKGEp
-fSwKRDQ6ZnVuY3Rpb24oYSl7dmFyIHMKZm9yKDtzPWEuZmlyc3RDaGlsZCxzIT1udWxsOylhLnJlbW92
-ZUNoaWxkKHMpfSwKdzpmdW5jdGlvbihhKXt2YXIgcz1hLm5vZGVWYWx1ZQpyZXR1cm4gcz09bnVsbD90
-aGlzLlUoYSk6c30sCnNhNDpmdW5jdGlvbihhLGIpe2EudGV4dENvbnRlbnQ9Yn0sCm1LOmZ1bmN0aW9u
-KGEsYixjKXtyZXR1cm4gYS5pbnNlcnRCZWZvcmUoYixjKX0sCiRpdUg6MX0KVy5CSC5wcm90b3R5cGU9
-ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQpp
-ZihiPj4+MCE9PWJ8fGI+PWEubGVuZ3RoKXRocm93IEguYihQLkNmKGIsYSxudWxsLG51bGwsbnVsbCkp
-CnJldHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3QuQS5hKGMpCnRocm93IEguYihQLkw0KCJD
-YW5ub3QgYXNzaWduIGVsZW1lbnQgb2YgaW1tdXRhYmxlIExpc3QuIikpfSwKZ3RIOmZ1bmN0aW9uKGEp
-e2lmKGEubGVuZ3RoPjApcmV0dXJuIGFbMF0KdGhyb3cgSC5iKFAuUFYoIk5vIGVsZW1lbnRzIikpfSwK
-RTpmdW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5ndGgpcmV0dXJuIEguT0goYSxiKQpyZXR1cm4g
-YVtiXX0sCiRpYlE6MSwKJGlYajoxLAokaWNYOjEsCiRpek06MX0KVy5TTi5wcm90b3R5cGU9e30KVy5l
-dy5wcm90b3R5cGU9eyRpZXc6MX0KVy5scC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4g
-YS5sZW5ndGh9fQpXLlRiLnByb3RvdHlwZT17CnI2OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIKaWYo
-ImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnByb3RvdHlwZSlyZXR1cm4g
-dGhpcy5EVyhhLGIsYyxkKQpzPVcuVTkoIjx0YWJsZT4iK0guRWooYikrIjwvdGFibGU+IixjLGQpCnI9
-ZG9jdW1lbnQuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnIudG9TdHJpbmcKcy50b1N0cmluZwpuZXcg
-Vy5lNyhyKS5GVigwLG5ldyBXLmU3KHMpKQpyZXR1cm4gcn19ClcuSXYucHJvdG90eXBlPXsKcjY6ZnVu
-Y3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAKaWYoImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4g
-d2luZG93LlJhbmdlLnByb3RvdHlwZSlyZXR1cm4gdGhpcy5EVyhhLGIsYyxkKQpzPWRvY3VtZW50CnI9
-cy5jcmVhdGVEb2N1bWVudEZyYWdtZW50KCkKcz1DLkllLnI2KHMuY3JlYXRlRWxlbWVudCgidGFibGUi
-KSxiLGMsZCkKcy50b1N0cmluZwpzPW5ldyBXLmU3KHMpCnE9cy5ncjgocykKcS50b1N0cmluZwpzPW5l
-dyBXLmU3KHEpCnA9cy5ncjgocykKci50b1N0cmluZwpwLnRvU3RyaW5nCm5ldyBXLmU3KHIpLkZWKDAs
-bmV3IFcuZTcocCkpCnJldHVybiByfX0KVy5XUC5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxk
-KXt2YXIgcyxyLHEKaWYoImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnBy
-b3RvdHlwZSlyZXR1cm4gdGhpcy5EVyhhLGIsYyxkKQpzPWRvY3VtZW50CnI9cy5jcmVhdGVEb2N1bWVu
-dEZyYWdtZW50KCkKcz1DLkllLnI2KHMuY3JlYXRlRWxlbWVudCgidGFibGUiKSxiLGMsZCkKcy50b1N0
-cmluZwpzPW5ldyBXLmU3KHMpCnE9cy5ncjgocykKci50b1N0cmluZwpxLnRvU3RyaW5nCm5ldyBXLmU3
-KHIpLkZWKDAsbmV3IFcuZTcocSkpCnJldHVybiByfX0KVy55WS5wcm90b3R5cGU9ewpwazpmdW5jdGlv
-bihhLGIsYyl7dmFyIHMscgp0aGlzLnNhNChhLG51bGwpCnM9YS5jb250ZW50CnMudG9TdHJpbmcKSi5i
-VChzKQpyPXRoaXMucjYoYSxiLG51bGwsYykKYS5jb250ZW50LmFwcGVuZENoaWxkKHIpfSwKWUM6ZnVu
-Y3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5wayhhLGIsbnVsbCl9LAokaXlZOjF9ClcudzYucHJvdG90eXBl
-PXt9ClcuSzUucHJvdG90eXBlPXsKUG86ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPVcuUDEoYS5vcGVuKGIs
-YykpCnJldHVybiBzfSwKZ21XOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxvY2F0aW9ufSwKdXM6ZnVuY3Rp
-b24oYSxiKXtyZXR1cm4gYS5jb25maXJtKGIpfSwKJGlLNToxLAokaXY2OjF9ClcuQ20ucHJvdG90eXBl
-PXskaUNtOjF9ClcuQ1EucHJvdG90eXBlPXskaUNROjF9ClcudzQucHJvdG90eXBlPXsKdzpmdW5jdGlv
-bihhKXt2YXIgcyxyPWEubGVmdApyLnRvU3RyaW5nCnI9IlJlY3RhbmdsZSAoIitILkVqKHIpKyIsICIK
-cz1hLnRvcApzLnRvU3RyaW5nCnM9citILkVqKHMpKyIpICIKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1z
-K0guRWoocikrIiB4ICIKcz1hLmhlaWdodApzLnRvU3RyaW5nCnJldHVybiByK0guRWoocyl9LApETjpm
-dW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoYj09bnVsbClyZXR1cm4hMQppZih0LnEuYihiKSl7cz1hLmxl
-ZnQKcy50b1N0cmluZwpyPWIubGVmdApyLnRvU3RyaW5nCmlmKHM9PT1yKXtzPWEudG9wCnMudG9TdHJp
-bmcKcj1iLnRvcApyLnRvU3RyaW5nCmlmKHM9PT1yKXtzPWEud2lkdGgKcy50b1N0cmluZwpyPWIud2lk
-dGgKci50b1N0cmluZwppZihzPT09cil7cz1hLmhlaWdodApzLnRvU3RyaW5nCnI9Yi5oZWlnaHQKci50
-b1N0cmluZwpyPXM9PT1yCnM9cn1lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITEK
-cmV0dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9YS5sZWZ0CnAudG9TdHJpbmcKcD1D
-LkNELmdpTyhwKQpzPWEudG9wCnMudG9TdHJpbmcKcz1DLkNELmdpTyhzKQpyPWEud2lkdGgKci50b1N0
-cmluZwpyPUMuQ0QuZ2lPKHIpCnE9YS5oZWlnaHQKcS50b1N0cmluZwpyZXR1cm4gVy5yRShwLHMscixD
-LkNELmdpTyhxKSl9fQpXLnJoLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0
-aH0sCnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+Pj4wIT09Ynx8Yj49YS5sZW5ndGgpdGhyb3cg
-SC5iKFAuQ2YoYixhLG51bGwsbnVsbCxudWxsKSkKcmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIs
-Yyl7dC5BLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBhc3NpZ24gZWxlbWVudCBvZiBpbW11dGFi
-bGUgTGlzdC4iKSl9LApFOmZ1bmN0aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1cm4gSC5P
-SChhLGIpCnJldHVybiBhW2JdfSwKJGliUToxLAokaVhqOjEsCiRpY1g6MSwKJGl6TToxfQpXLmNmLnBy
-b3RvdHlwZT17Cks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCnQuZUEuYShiKQpmb3Iocz10aGlz
-Lmd2YygpLHI9cy5sZW5ndGgscT10aGlzLmEscD0wO3A8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxI
-LmxrKShzKSwrK3Ape289c1twXQpiLiQyKG8scS5nZXRBdHRyaWJ1dGUobykpfX0sCmd2YzpmdW5jdGlv
-bigpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMuYS5hdHRyaWJ1dGVzCm0udG9TdHJpbmcKcz1ILlZNKFtd
-LHQucykKZm9yKHI9bS5sZW5ndGgscT10Lmg5LHA9MDtwPHI7KytwKXtpZihwPj1tLmxlbmd0aClyZXR1
-cm4gSC5PSChtLHApCm89cS5hKG1bcF0pCmlmKG8ubmFtZXNwYWNlVVJJPT1udWxsKXtuPW8ubmFtZQpu
-LnRvU3RyaW5nCkMuTm0uaShzLG4pfX1yZXR1cm4gc30sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhp
-cy5ndmMoKS5sZW5ndGg9PT0wfX0KVy5pNy5wcm90b3R5cGU9ewp4NDpmdW5jdGlvbihhKXt2YXIgcz1I
-Lm9UKHRoaXMuYS5oYXNBdHRyaWJ1dGUoYSkpCnJldHVybiBzfSwKcTpmdW5jdGlvbihhLGIpe3JldHVy
-biB0aGlzLmEuZ2V0QXR0cmlidXRlKEguaChiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5hLnNl
-dEF0dHJpYnV0ZShiLGMpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3RofX0K
-Vy5TeS5wcm90b3R5cGU9ewp4NDpmdW5jdGlvbihhKXt2YXIgcz1ILm9UKHRoaXMuYS5hLmhhc0F0dHJp
-YnV0ZSgiZGF0YS0iK3RoaXMuUChhKSkpCnJldHVybiBzfSwKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0
-aGlzLmEuYS5nZXRBdHRyaWJ1dGUoImRhdGEtIit0aGlzLlAoSC5oKGIpKSl9LApZNTpmdW5jdGlvbihh
-LGIsYyl7dGhpcy5hLmEuc2V0QXR0cmlidXRlKCJkYXRhLSIrdGhpcy5QKGIpLGMpfSwKSzpmdW5jdGlv
-bihhLGIpe3RoaXMuYS5LKDAsbmV3IFcuS1ModGhpcyx0LmVBLmEoYikpKX0sCmd2YzpmdW5jdGlvbigp
-e3ZhciBzPUguVk0oW10sdC5zKQp0aGlzLmEuSygwLG5ldyBXLkEzKHRoaXMscykpCnJldHVybiBzfSwK
-Z0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3Jl
-dHVybiB0aGlzLmd2YygpLmxlbmd0aD09PTB9LAp4cTpmdW5jdGlvbihhKXt2YXIgcyxyLHE9SC5WTShh
-LnNwbGl0KCItIiksdC5zKQpmb3Iocz0xO3M8cS5sZW5ndGg7KytzKXtyPXFbc10KaWYoci5sZW5ndGg+
-MClDLk5tLlk1KHEscyxyWzBdLnRvVXBwZXJDYXNlKCkrSi5LVihyLDEpKX1yZXR1cm4gQy5ObS5rKHEs
-IiIpfSwKUDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvCmZvcihzPWEubGVuZ3RoLHI9MCxxPSIiO3I8
-czsrK3Ipe3A9YVtyXQpvPXAudG9Mb3dlckNhc2UoKQpxPShwIT09byYmcj4wP3ErIi0iOnEpK299cmV0
-dXJuIHEuY2hhckNvZGVBdCgwKT09MD9xOnF9fQpXLktTLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEs
-Yil7aWYoSi5yWShhKS5uQyhhLCJkYXRhLSIpKXRoaXMuYi4kMih0aGlzLmEueHEoQy54Qi55bihhLDUp
-KSxiKX0sCiRTOjE0fQpXLkEzLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7aWYoSi5yWShhKS5u
-QyhhLCJkYXRhLSIpKUMuTm0uaSh0aGlzLmIsdGhpcy5hLnhxKEMueEIueW4oYSw1KSkpfSwKJFM6MTR9
-ClcuSTQucHJvdG90eXBlPXsKRDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89UC5Mcyh0Lk4pCmZvcihz
-PXRoaXMuYS5jbGFzc05hbWUuc3BsaXQoIiAiKSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPUouVDAo
-c1txXSkKaWYocC5sZW5ndGghPT0wKW8uaSgwLHApfXJldHVybiBvfSwKWDpmdW5jdGlvbihhKXt0aGlz
-LmEuY2xhc3NOYW1lPXQuQy5hKGEpLmsoMCwiICIpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
-YS5jbGFzc0xpc3QubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2xhc3NMaXN0
-Lmxlbmd0aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3Ro
-IT09MH0sClYxOmZ1bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05hbWU9IiJ9LAp0ZzpmdW5jdGlvbihhLGIp
-e3ZhciBzPXRoaXMuYS5jbGFzc0xpc3QuY29udGFpbnMoYikKcmV0dXJuIHN9LAppOmZ1bmN0aW9uKGEs
-Yil7dmFyIHMscgpILmgoYikKcz10aGlzLmEuY2xhc3NMaXN0CnI9cy5jb250YWlucyhiKQpzLmFkZChi
-KQpyZXR1cm4hcn0sCkw6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYodHlwZW9mIGI9PSJzdHJpbmci
-KXtzPXRoaXMuYS5jbGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMucmVtb3ZlKGIpCnE9cn1lbHNlIHE9
-ITEKcmV0dXJuIHF9LApGVjpmdW5jdGlvbihhLGIpe1cuVE4odGhpcy5hLHQuUS5hKGIpKX19ClcuRmsu
-cHJvdG90eXBlPXt9ClcuUk8ucHJvdG90eXBlPXt9ClcuZXUucHJvdG90eXBlPXt9ClcueEMucHJvdG90
-eXBlPXt9Clcudk4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMSh0LkIu
-YShhKSl9LAokUzoyN30KVy5KUS5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhKXt2YXIgcwppZigkLm9y
-LmE9PT0wKXtmb3Iocz0wO3M8MjYyOysrcykkLm9yLlk1KDAsQy5jbVtzXSxXLnBTKCkpCmZvcihzPTA7
-czwxMjsrK3MpJC5vci5ZNSgwLEMuQklbc10sVy5WNCgpKX19LAppMDpmdW5jdGlvbihhKXtyZXR1cm4g
-JC5BTigpLnRnKDAsVy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9JC5vci5xKDAsSC5F
-aihXLnJTKGEpKSsiOjoiK2IpCmlmKHM9PW51bGwpcz0kLm9yLnEoMCwiKjo6IitiKQppZihzPT1udWxs
-KXJldHVybiExCnJldHVybiBILnk4KHMuJDQoYSxiLGMsdGhpcykpfSwKJGlrRjoxfQpXLkdtLnByb3Rv
-dHlwZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5XOShhLHRoaXMuZ0EoYSksSC56KGEpLkMo
-Ilc5PEdtLkU+IikpfX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1cm4gQy5ObS5W
-cih0aGlzLmEsbmV3IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBDLk5tLlZyKHRo
-aXMuYSxuZXcgVy5FZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
-KGEpe3JldHVybiB0LmY2LmEoYSkuaTAodGhpcy5hKX0sCiRTOjE1fQpXLkVnLnByb3RvdHlwZT17CiQx
-OmZ1bmN0aW9uKGEpe3JldHVybiB0LmY2LmEoYSkuRWIodGhpcy5hLHRoaXMuYix0aGlzLmMpfSwKJFM6
-MTV9ClcubTYucHJvdG90eXBlPXsKQ1k6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxCnRoaXMuYS5G
-VigwLGMpCnM9Yi5ldigwLG5ldyBXLkVvKCkpCnI9Yi5ldigwLG5ldyBXLldrKCkpCnRoaXMuYi5GVigw
-LHMpCnE9dGhpcy5jCnEuRlYoMCxDLnhEKQpxLkZWKDAscil9LAppMDpmdW5jdGlvbihhKXtyZXR1cm4g
-dGhpcy5hLnRnKDAsVy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9dGhpcyxyPVcuclMo
-YSkscT1zLmMKaWYocS50ZygwLEguRWoocikrIjo6IitiKSlyZXR1cm4gcy5kLkR0KGMpCmVsc2UgaWYo
-cS50ZygwLCIqOjoiK2IpKXJldHVybiBzLmQuRHQoYykKZWxzZXtxPXMuYgppZihxLnRnKDAsSC5Faihy
-KSsiOjoiK2IpKXJldHVybiEwCmVsc2UgaWYocS50ZygwLCIqOjoiK2IpKXJldHVybiEwCmVsc2UgaWYo
-cS50ZygwLEguRWoocikrIjo6KiIpKXJldHVybiEwCmVsc2UgaWYocS50ZygwLCIqOjoqIikpcmV0dXJu
-ITB9cmV0dXJuITF9LAokaWtGOjF9ClcuRW8ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJu
-IUMuTm0udGcoQy5CSSxILmgoYSkpfSwKJFM6Nn0KVy5Xay5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihh
-KXtyZXR1cm4gQy5ObS50ZyhDLkJJLEguaChhKSl9LAokUzo2fQpXLmN0LnByb3RvdHlwZT17CkViOmZ1
-bmN0aW9uKGEsYixjKXtpZih0aGlzLmpGKGEsYixjKSlyZXR1cm4hMAppZihiPT09InRlbXBsYXRlIiYm
-Yz09PSIiKXJldHVybiEwCmlmKGEuZ2V0QXR0cmlidXRlKCJ0ZW1wbGF0ZSIpPT09IiIpcmV0dXJuIHRo
-aXMuZS50ZygwLGIpCnJldHVybiExfX0KVy5JQS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1
-cm4iVEVNUExBVEU6OiIrSC5FaihILmgoYSkpfSwKJFM6NX0KVy5Pdy5wcm90b3R5cGU9ewppMDpmdW5j
-dGlvbihhKXt2YXIgcwppZih0LmV3LmIoYSkpcmV0dXJuITEKcz10Lmc3LmIoYSkKaWYocyYmVy5yUyhh
-KT09PSJmb3JlaWduT2JqZWN0IilyZXR1cm4hMQppZihzKXJldHVybiEwCnJldHVybiExfSwKRWI6ZnVu
-Y3Rpb24oYSxiLGMpe2lmKGI9PT0iaXMifHxDLnhCLm5DKGIsIm9uIikpcmV0dXJuITEKcmV0dXJuIHRo
-aXMuaTAoYSl9LAokaWtGOjF9ClcuVzkucHJvdG90eXBlPXsKRjpmdW5jdGlvbigpe3ZhciBzPXRoaXMs
-cj1zLmMrMSxxPXMuYgppZihyPHEpe3Muc3AoSi54OShzLmEscikpCnMuYz1yCnJldHVybiEwfXMuc3Ao
-bnVsbCkKcy5jPXEKcmV0dXJuITF9LApnbDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmR9LApzcDpmdW5j
-dGlvbihhKXt0aGlzLmQ9dGhpcy4kdGkuQygiMT8iKS5hKGEpfSwKJGlBbjoxfQpXLmRXLnByb3RvdHlw
-ZT17JGlEMDoxLCRpdjY6MX0KVy5tay5wcm90b3R5cGU9eyRpeTA6MX0KVy5Lby5wcm90b3R5cGU9ewpQ
-bjpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9bmV3IFcuZm0ocykKcy5iPSExCnIuJDIoYSxudWxsKQpm
-b3IoO3MuYjspe3MuYj0hMQpyLiQyKGEsbnVsbCl9fSwKRVA6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlz
-LmI9ITAKaWYoYiE9bnVsbD9iIT09YS5wYXJlbnROb2RlOnMpSi5MdChhKQplbHNlIGIucmVtb3ZlQ2hp
-bGQoYSl9LApJNDpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbj0hMCxtPW51bGwsbD1udWxsCnRy
-eXttPUouaWcoYSkKbD1tLmEuZ2V0QXR0cmlidXRlKCJpcyIpCnQuaC5hKGEpCnM9ZnVuY3Rpb24oYyl7
-aWYoIShjLmF0dHJpYnV0ZXMgaW5zdGFuY2VvZiBOYW1lZE5vZGVNYXApKXJldHVybiB0cnVlCmlmKGMu
-aWQ9PSdsYXN0Q2hpbGQnfHxjLm5hbWU9PSdsYXN0Q2hpbGQnfHxjLmlkPT0ncHJldmlvdXNTaWJsaW5n
-J3x8Yy5uYW1lPT0ncHJldmlvdXNTaWJsaW5nJ3x8Yy5pZD09J2NoaWxkcmVuJ3x8Yy5uYW1lPT0nY2hp
-bGRyZW4nKXJldHVybiB0cnVlCnZhciBrPWMuY2hpbGROb2RlcwppZihjLmxhc3RDaGlsZCYmYy5sYXN0
-Q2hpbGQhPT1rW2subGVuZ3RoLTFdKXJldHVybiB0cnVlCmlmKGMuY2hpbGRyZW4paWYoIShjLmNoaWxk
-cmVuIGluc3RhbmNlb2YgSFRNTENvbGxlY3Rpb258fGMuY2hpbGRyZW4gaW5zdGFuY2VvZiBOb2RlTGlz
-dCkpcmV0dXJuIHRydWUKdmFyIGo9MAppZihjLmNoaWxkcmVuKWo9Yy5jaGlsZHJlbi5sZW5ndGgKZm9y
-KHZhciBpPTA7aTxqO2krKyl7dmFyIGg9Yy5jaGlsZHJlbltpXQppZihoLmlkPT0nYXR0cmlidXRlcyd8
-fGgubmFtZT09J2F0dHJpYnV0ZXMnfHxoLmlkPT0nbGFzdENoaWxkJ3x8aC5uYW1lPT0nbGFzdENoaWxk
-J3x8aC5pZD09J3ByZXZpb3VzU2libGluZyd8fGgubmFtZT09J3ByZXZpb3VzU2libGluZyd8fGguaWQ9
-PSdjaGlsZHJlbid8fGgubmFtZT09J2NoaWxkcmVuJylyZXR1cm4gdHJ1ZX1yZXR1cm4gZmFsc2V9KGEp
-Cm49SC5vVChzKT8hMDohKGEuYXR0cmlidXRlcyBpbnN0YW5jZW9mIE5hbWVkTm9kZU1hcCl9Y2F0Y2go
-cCl7SC5SdShwKX1yPSJlbGVtZW50IHVucHJpbnRhYmxlIgp0cnl7cj1KLmooYSl9Y2F0Y2gocCl7SC5S
-dShwKX10cnl7cT1XLnJTKGEpCnRoaXMua1IodC5oLmEoYSksYixuLHIscSx0LmYuYShtKSxILmsobCkp
-fWNhdGNoKHApe2lmKEguUnUocCkgaW5zdGFuY2VvZiBQLnUpdGhyb3cgcAplbHNle3RoaXMuRVAoYSxi
-KQp3aW5kb3cKbz0iUmVtb3ZpbmcgY29ycnVwdGVkIGVsZW1lbnQgIitILkVqKHIpCmlmKHR5cGVvZiBj
-b25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKG8pfX19LAprUjpmdW5jdGlvbihh
-LGIsYyxkLGUsZixnKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzCmlmKGMpe20uRVAoYSxiKQp3aW5kb3cK
-cz0iUmVtb3ZpbmcgZWxlbWVudCBkdWUgdG8gY29ycnVwdGVkIGF0dHJpYnV0ZXMgb24gPCIrZCsiPiIK
-aWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0dXJu
-fWlmKCFtLmEuaTAoYSkpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBlbGVt
-ZW50IDwiK0guRWooZSkrIj4gZnJvbSAiK0guRWooYikKaWYodHlwZW9mIGNvbnNvbGUhPSJ1bmRlZmlu
-ZWQiKXdpbmRvdy5jb25zb2xlLndhcm4ocykKcmV0dXJufWlmKGchPW51bGwpaWYoIW0uYS5FYihhLCJp
-cyIsZykpe20uRVAoYSxiKQp3aW5kb3cKcz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCB0eXBlIGV4dGVuc2lv
-biA8IitILkVqKGUpKycgaXM9IicrZysnIj4nCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3
-aW5kb3cuY29uc29sZS53YXJuKHMpCnJldHVybn1zPWYuZ3ZjKCkKcj1ILlZNKHMuc2xpY2UoMCksSC50
-NihzKSkKZm9yKHE9Zi5ndmMoKS5sZW5ndGgtMSxzPWYuYTtxPj0wOy0tcSl7aWYocT49ci5sZW5ndGgp
-cmV0dXJuIEguT0gocixxKQpwPXJbcV0Kbz1tLmEKbj1KLmNIKHApCkguaChwKQppZighby5FYihhLG4s
-cy5nZXRBdHRyaWJ1dGUocCkpKXt3aW5kb3cKbz0iUmVtb3ZpbmcgZGlzYWxsb3dlZCBhdHRyaWJ1dGUg
-PCIrSC5FaihlKSsiICIrcCsnPSInK0guRWoocy5nZXRBdHRyaWJ1dGUocCkpKyciPicKaWYodHlwZW9m
-IGNvbnNvbGUhPSJ1bmRlZmluZWQiKXdpbmRvdy5jb25zb2xlLndhcm4obykKcy5yZW1vdmVBdHRyaWJ1
-dGUocCl9fWlmKHQuYVcuYihhKSl7cz1hLmNvbnRlbnQKcy50b1N0cmluZwptLlBuKHMpfX0sCiRpb246
-MX0KVy5mbS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtPXRoaXMu
-YQpzd2l0Y2goYS5ub2RlVHlwZSl7Y2FzZSAxOm0uSTQoYSxiKQpicmVhawpjYXNlIDg6Y2FzZSAxMTpj
-YXNlIDM6Y2FzZSA0OmJyZWFrCmRlZmF1bHQ6bS5FUChhLGIpfXM9YS5sYXN0Q2hpbGQKZm9yKHE9dC5B
-O251bGwhPXM7KXtyPW51bGwKdHJ5e3I9cy5wcmV2aW91c1NpYmxpbmcKaWYociE9bnVsbCl7cD1yLm5l
-eHRTaWJsaW5nCm89cwpvPXA9PW51bGw/byE9bnVsbDpwIT09bwpwPW99ZWxzZSBwPSExCmlmKHApe3A9
-UC5QVigiQ29ycnVwdCBIVE1MIikKdGhyb3cgSC5iKHApfX1jYXRjaChuKXtILlJ1KG4pCnA9cS5hKHMp
-Cm0uYj0hMApvPXAucGFyZW50Tm9kZQpvPWE9PW51bGw/byE9bnVsbDphIT09bwppZihvKXtvPXAucGFy
-ZW50Tm9kZQppZihvIT1udWxsKW8ucmVtb3ZlQ2hpbGQocCl9ZWxzZSBhLnJlbW92ZUNoaWxkKHApCnM9
-bnVsbApyPWEubGFzdENoaWxkfWlmKHMhPW51bGwpdGhpcy4kMihzLGEpCnM9cn19LAokUzozMH0KVy5M
-ZS5wcm90b3R5cGU9e30KVy5LNy5wcm90b3R5cGU9e30KVy5yQi5wcm90b3R5cGU9e30KVy5YVy5wcm90
-b3R5cGU9e30KVy5vYS5wcm90b3R5cGU9e30KUC5pSi5wcm90b3R5cGU9ewpWSDpmdW5jdGlvbihhKXt2
-YXIgcyxyPXRoaXMuYSxxPXIubGVuZ3RoCmZvcihzPTA7czxxOysrcylpZihyW3NdPT09YSlyZXR1cm4g
-cwpDLk5tLmkocixhKQpDLk5tLmkodGhpcy5iLG51bGwpCnJldHVybiBxfSwKUHY6ZnVuY3Rpb24oYSl7
-dmFyIHMscixxLHA9dGhpcyxvPXt9CmlmKGE9PW51bGwpcmV0dXJuIGEKaWYoSC5sKGEpKXJldHVybiBh
-CmlmKHR5cGVvZiBhPT0ibnVtYmVyIilyZXR1cm4gYQppZih0eXBlb2YgYT09InN0cmluZyIpcmV0dXJu
-IGEKaWYoYSBpbnN0YW5jZW9mIFAuaVApcmV0dXJuIG5ldyBEYXRlKGEuYSkKaWYodC5mdi5iKGEpKXRo
-cm93IEguYihQLlNZKCJzdHJ1Y3R1cmVkIGNsb25lIG9mIFJlZ0V4cCIpKQppZih0LmM4LmIoYSkpcmV0
-dXJuIGEKaWYodC53LmIoYSkpcmV0dXJuIGEKaWYodC5JLmIoYSkpcmV0dXJuIGEKcz10LmRFLmIoYSl8
-fCExCmlmKHMpcmV0dXJuIGEKaWYodC5mLmIoYSkpe3I9cC5WSChhKQpzPXAuYgppZihyPj1zLmxlbmd0
-aClyZXR1cm4gSC5PSChzLHIpCnE9by5hPXNbcl0KaWYocSE9bnVsbClyZXR1cm4gcQpxPXt9Cm8uYT1x
-CkMuTm0uWTUocyxyLHEpCmEuSygwLG5ldyBQLmpnKG8scCkpCnJldHVybiBvLmF9aWYodC5qLmIoYSkp
-e3I9cC5WSChhKQpvPXAuYgppZihyPj1vLmxlbmd0aClyZXR1cm4gSC5PSChvLHIpCnE9b1tyXQppZihx
-IT1udWxsKXJldHVybiBxCnJldHVybiBwLmVrKGEscil9aWYodC5lSC5iKGEpKXtyPXAuVkgoYSkKcz1w
-LmIKaWYocj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxyKQpxPW8uYj1zW3JdCmlmKHEhPW51bGwpcmV0
-dXJuIHEKcT17fQpvLmI9cQpDLk5tLlk1KHMscixxKQpwLmltKGEsbmV3IFAuVGEobyxwKSkKcmV0dXJu
-IG8uYn10aHJvdyBILmIoUC5TWSgic3RydWN0dXJlZCBjbG9uZSBvZiBvdGhlciB0eXBlIikpfSwKZWs6
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPUouVTYoYSkscT1yLmdBKGEpLHA9bmV3IEFycmF5KHEpCkMuTm0u
-WTUodGhpcy5iLGIscCkKZm9yKHM9MDtzPHE7KytzKUMuTm0uWTUocCxzLHRoaXMuUHYoci5xKGEscykp
-KQpyZXR1cm4gcH19ClAuamcucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuYVthXT10
-aGlzLmIuUHYoYil9LAokUzozMX0KUC5UYS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3RoaXMu
-YS5iW2FdPXRoaXMuYi5QdihiKX0sCiRTOjE2fQpQLkJmLnByb3RvdHlwZT17CmltOmZ1bmN0aW9uKGEs
-Yil7dmFyIHMscixxLHAKdC5iOC5hKGIpCmZvcihzPU9iamVjdC5rZXlzKGEpLHI9cy5sZW5ndGgscT0w
-O3E8cjsrK3Epe3A9c1txXQpiLiQyKHAsYVtwXSl9fX0KUC5Bcy5wcm90b3R5cGU9ewpWOmZ1bmN0aW9u
-KGEpe3ZhciBzCkguaChhKQpzPSQuaEcoKS5iCmlmKHR5cGVvZiBhIT0ic3RyaW5nIilILnYoSC50TChh
-KSkKaWYocy50ZXN0KGEpKXJldHVybiBhCnRocm93IEguYihQLkwzKGEsInZhbHVlIiwiTm90IGEgdmFs
-aWQgY2xhc3MgdG9rZW4iKSl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5rKDAsIiAiKX0s
-CmdtOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuRCgpCnJldHVybiBQLnJqKHMscy5yLEguTGgocykuYyl9
-LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuRCgpLmE9PT0wfSwKZ29yOmZ1bmN0aW9uKGEpe3Jl
-dHVybiB0aGlzLkQoKS5hIT09MH0sCmdBOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hfSwKdGc6
-ZnVuY3Rpb24oYSxiKXt0aGlzLlYoYikKcmV0dXJuIHRoaXMuRCgpLnRnKDAsYil9LAppOmZ1bmN0aW9u
-KGEsYil7dmFyIHMKSC5oKGIpCnRoaXMuVihiKQpzPXRoaXMuTyhuZXcgUC5HRShiKSkKcmV0dXJuIEgu
-eTgocz09bnVsbD8hMTpzKX0sCkw6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyCmlmKHR5cGVvZiBiIT0ic3Ry
-aW5nIilyZXR1cm4hMQp0aGlzLlYoYikKcz10aGlzLkQoKQpyPXMuTCgwLGIpCnRoaXMuWChzKQpyZXR1
-cm4gcn0sCkZWOmZ1bmN0aW9uKGEsYil7dGhpcy5PKG5ldyBQLk43KHRoaXMsdC5RLmEoYikpKX0sCmVS
-OmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5EKCkKcmV0dXJuIEguYksocyxiLEguTGgocykuQygibGYu
-RSIpKX0sCkU6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gdGhpcy5EKCkuRSgwLGIpfSwKVjE6ZnVuY3Rpb24o
-YSl7dGhpcy5PKG5ldyBQLnVRKCkpfSwKTzpmdW5jdGlvbihhKXt2YXIgcyxyCnQuYlUuYShhKQpzPXRo
-aXMuRCgpCnI9YS4kMShzKQp0aGlzLlgocykKcmV0dXJuIHJ9fQpQLkdFLnByb3RvdHlwZT17CiQxOmZ1
-bmN0aW9uKGEpe3JldHVybiB0LkMuYShhKS5pKDAsdGhpcy5hKX0sCiRTOjMzfQpQLk43LnByb3RvdHlw
-ZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYixyPUgudDYocykKcmV0dXJuIHQuQy5hKGEpLkZW
-KDAsbmV3IEgubEoocyxyLkMoInFVKDEpIikuYSh0aGlzLmEuZ3VNKCkpLHIuQygibEo8MSxxVT4iKSkp
-fSwKJFM6MTd9ClAudVEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dC5DLmEoYSkKaWYoYS5hPjAp
-e2EuYj1hLmM9YS5kPWEuZT1hLmY9bnVsbAphLmE9MAphLkdZKCl9cmV0dXJuIG51bGx9LAokUzoxN30K
-UC5oRi5wcm90b3R5cGU9eyRpaEY6MX0KUC5QQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIg
-cwp0LlkuYShhKQpzPWZ1bmN0aW9uKGIsYyxkKXtyZXR1cm4gZnVuY3Rpb24oKXtyZXR1cm4gYihjLGQs
-dGhpcyxBcnJheS5wcm90b3R5cGUuc2xpY2UuYXBwbHkoYXJndW1lbnRzKSl9fShQLlI0LGEsITEpClAu
-RG0ocywkLncoKSxhKQpyZXR1cm4gc30sCiRTOjR9ClAubXQucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
-YSl7cmV0dXJuIG5ldyB0aGlzLmEoYSl9LAokUzo0fQpQLk56LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
-KGEpe3JldHVybiBuZXcgUC5yNyhhKX0sCiRTOjM1fQpQLlFTLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
-KGEpe3JldHVybiBuZXcgUC5UeihhLHQuYW0pfSwKJFM6NTR9ClAubnAucHJvdG90eXBlPXsKJDE6ZnVu
-Y3Rpb24oYSl7cmV0dXJuIG5ldyBQLkU0KGEpfSwKJFM6Mzd9ClAuRTQucHJvdG90eXBlPXsKcTpmdW5j
-dGlvbihhLGIpe2lmKHR5cGVvZiBiIT0ic3RyaW5nIiYmdHlwZW9mIGIhPSJudW1iZXIiKXRocm93IEgu
-YihQLnhZKCJwcm9wZXJ0eSBpcyBub3QgYSBTdHJpbmcgb3IgbnVtIikpCnJldHVybiBQLmRVKHRoaXMu
-YVtiXSl9LApZNTpmdW5jdGlvbihhLGIsYyl7aWYodHlwZW9mIGIhPSJzdHJpbmciJiZ0eXBlb2YgYiE9
-Im51bWJlciIpdGhyb3cgSC5iKFAueFkoInByb3BlcnR5IGlzIG5vdCBhIFN0cmluZyBvciBudW0iKSkK
-dGhpcy5hW2JdPVAud1koYyl9LApETjpmdW5jdGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKcmV0
-dXJuIGIgaW5zdGFuY2VvZiBQLkU0JiZ0aGlzLmE9PT1iLmF9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIK
-dHJ5e3M9U3RyaW5nKHRoaXMuYSkKcmV0dXJuIHN9Y2F0Y2gocil7SC5SdShyKQpzPXRoaXMueGIoMCkK
-cmV0dXJuIHN9fSwKVjc6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyPXRoaXMuYQppZihiPT1udWxsKXM9bnVs
-bAplbHNle3M9SC50NihiKQpzPVAuQ0gobmV3IEgubEooYixzLkMoIkAoMSkiKS5hKFAuaUcoKSkscy5D
-KCJsSjwxLEA+IikpLCEwLHQueil9cmV0dXJuIFAuZFUoclthXS5hcHBseShyLHMpKX0sCmdpTzpmdW5j
-dGlvbihhKXtyZXR1cm4gMH19ClAucjcucHJvdG90eXBlPXt9ClAuVHoucHJvdG90eXBlPXsKY1A6ZnVu
-Y3Rpb24oYSl7dmFyIHM9dGhpcyxyPWE8MHx8YT49cy5nQShzKQppZihyKXRocm93IEguYihQLlRFKGEs
-MCxzLmdBKHMpLG51bGwsbnVsbCkpfSwKcTpmdW5jdGlvbihhLGIpe2lmKEgub2soYikpdGhpcy5jUChi
-KQpyZXR1cm4gdGhpcy4kdGkuYy5hKHRoaXMuVXIoMCxiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhp
-cy5jUChiKQp0aGlzLmU0KDAsYixjKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYS5sZW5ndGgK
-aWYodHlwZW9mIHM9PT0ibnVtYmVyIiYmcz4+PjA9PT1zKXJldHVybiBzCnRocm93IEguYihQLlBWKCJC
-YWQgSnNBcnJheSBsZW5ndGgiKSl9LAokaWJROjEsCiRpY1g6MSwKJGl6TToxfQpQLmNvLnByb3RvdHlw
-ZT17fQpQLm5kLnByb3RvdHlwZT17JGluZDoxfQpQLktlLnByb3RvdHlwZT17CkQ6ZnVuY3Rpb24oKXt2
-YXIgcyxyLHEscCxvPXRoaXMuYS5nZXRBdHRyaWJ1dGUoImNsYXNzIiksbj1QLkxzKHQuTikKaWYobz09
-bnVsbClyZXR1cm4gbgpmb3Iocz1vLnNwbGl0KCIgIikscj1zLmxlbmd0aCxxPTA7cTxyOysrcSl7cD1K
-LlQwKHNbcV0pCmlmKHAubGVuZ3RoIT09MCluLmkoMCxwKX1yZXR1cm4gbn0sClg6ZnVuY3Rpb24oYSl7
-dGhpcy5hLnNldEF0dHJpYnV0ZSgiY2xhc3MiLGEuaygwLCIgIikpfX0KUC5oaS5wcm90b3R5cGU9ewpn
-bjpmdW5jdGlvbihhKXtyZXR1cm4gbmV3IFAuS2UoYSl9LApzaGY6ZnVuY3Rpb24oYSxiKXt0aGlzLllD
-KGEsYil9LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxyLHEscCxvLG4KaWYoZD09bnVsbCl7cz1I
-LlZNKFtdLHQudikKZD1uZXcgVy52RChzKQpDLk5tLmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJs
-KCkpCkMuTm0uaShzLG5ldyBXLk93KCkpfWM9bmV3IFcuS28oZCkKcj0nPHN2ZyB2ZXJzaW9uPSIxLjEi
-PicrSC5FaihiKSsiPC9zdmc+IgpzPWRvY3VtZW50CnE9cy5ib2R5CnEudG9TdHJpbmcKcD1DLlJZLkFI
-KHEscixjKQpvPXMuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnAudG9TdHJpbmcKcz1uZXcgVy5lNyhw
-KQpuPXMuZ3I4KHMpCmZvcig7cz1uLmZpcnN0Q2hpbGQscyE9bnVsbDspby5hcHBlbmRDaGlsZChzKQpy
-ZXR1cm4gb30sCm56OmZ1bmN0aW9uKGEsYixjLGQsZSl7dGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBpbnZv
-a2UgaW5zZXJ0QWRqYWNlbnRIdG1sIG9uIFNWRy4iKSl9LApnVmw6ZnVuY3Rpb24oYSl7cmV0dXJuIG5l
-dyBXLmV1KGEsImNsaWNrIiwhMSx0LmspfSwKJGloaToxfQpNLkg3LnByb3RvdHlwZT17Cnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIHRoaXMuYn19ClUuTEwucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4g
-UC5FRihbIm5vZGVJZCIsdGhpcy5iLCJraW5kIix0aGlzLmEuYV0sdC5YLHQuXyl9fQpVLk1ELnByb3Rv
-dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0LmZFLmEoYSkuYT09PXRoaXMuYS5xKDAsImtpbmQi
-KX0sCiRTOjM4fQpVLmQyLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbz10aGlz
-LG49dC5YLG09dC5fLGw9UC5GbChuLG0pLGs9by5hCmlmKGshPW51bGwpe3M9SC5WTShbXSx0LkcpCmZv
-cihyPWsubGVuZ3RoLHE9MDtxPGsubGVuZ3RoO2subGVuZ3RoPT09cnx8KDAsSC5saykoayksKytxKXtw
-PWtbcV0Kcy5wdXNoKFAuRUYoWyJkZXNjcmlwdGlvbiIscC5hLCJocmVmIixwLmJdLG4sbSkpfWwuWTUo
-MCwiZWRpdHMiLHMpfWwuWTUoMCwiZXhwbGFuYXRpb24iLG8uYikKbC5ZNSgwLCJsaW5lIixvLmMpCmwu
-WTUoMCwiZGlzcGxheVBhdGgiLG8uZCkKbC5ZNSgwLCJ1cmlQYXRoIixvLmUpCm49by5mCmlmKG4hPW51
-bGwpe209SC5WTShbXSx0LkcpCmZvcihrPW4ubGVuZ3RoLHE9MDtxPG4ubGVuZ3RoO24ubGVuZ3RoPT09
-a3x8KDAsSC5saykobiksKytxKW0ucHVzaChuW3FdLkx0KCkpCmwuWTUoMCwidHJhY2VzIixtKX1yZXR1
-cm4gbH19ClUuU2UucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihbImRlc2NyaXB0
-aW9uIix0aGlzLmEsImhyZWYiLHRoaXMuYl0sdC5YLHQuXyl9fQpVLk1sLnByb3RvdHlwZT17Ckx0OmZ1
-bmN0aW9uKCl7cmV0dXJuIFAuRUYoWyJocmVmIix0aGlzLmEsImxpbmUiLHRoaXMuYiwicGF0aCIsdGhp
-cy5jXSx0LlgsdC5fKX19ClUueUQucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscD1I
-LlZNKFtdLHQuRykKZm9yKHM9dGhpcy5iLHI9cy5sZW5ndGgscT0wO3E8cy5sZW5ndGg7cy5sZW5ndGg9
-PT1yfHwoMCxILmxrKShzKSwrK3EpcC5wdXNoKHNbcV0uTHQoKSkKcmV0dXJuIFAuRUYoWyJkZXNjcmlw
-dGlvbiIsdGhpcy5hLCJlbnRyaWVzIixwXSx0LlgsdC5fKX19ClUud2IucHJvdG90eXBlPXsKTHQ6ZnVu
-Y3Rpb24oKXt2YXIgcyxyLHEscD10aGlzLG89UC5GbCh0LlgsdC5fKQpvLlk1KDAsImRlc2NyaXB0aW9u
-IixwLmEpCnM9cC5iCmlmKHMhPW51bGwpby5ZNSgwLCJmdW5jdGlvbiIscykKcz1wLmMKaWYocyE9bnVs
-bClvLlk1KDAsImxpbmsiLHMuTHQoKSkKcz1wLmQKaWYocy5sZW5ndGghPT0wKXtyPUgudDYocykKcT1y
-LkMoImxKPDEsWjA8cVUqLE1oKj4qPiIpCm8uWTUoMCwiaGludEFjdGlvbnMiLFAuWTEobmV3IEgubEoo
-cyxyLkMoIlowPHFVKixNaCo+KigxKSIpLmEobmV3IFUuYjAoKSkscSksITAscS5DKCJhTC5FIikpKX1y
-ZXR1cm4gb319ClUuYU4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIFUubnoodC50LmEo
-YSkpfSwKJFM6Mzl9ClUuYjAucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHQuYVguYShh
-KS5MdCgpfSwKJFM6NDB9CkIuajgucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXtyZXR1cm4gUC5FRihb
-ImxpbmUiLHRoaXMuYSwiZXhwbGFuYXRpb24iLHRoaXMuYiwib2Zmc2V0Iix0aGlzLmNdLHQuWCx0Ll8p
-fX0KQi5xcC5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG8sbixtLGw9dGhpcyxr
-PXQuWCxqPVAuRmwoayx0LmRwKQpmb3Iocz1sLmQscz1zLmdQdShzKSxzPXMuZ20ocykscj10Ll8scT10
-Lkc7cy5GKCk7KXtwPXMuZ2woKQpvPXAuYQpuPUguVk0oW10scSkKZm9yKHA9Si5JVChwLmIpO3AuRigp
-Oyl7bT1wLmdsKCkKbi5wdXNoKFAuRUYoWyJsaW5lIixtLmEsImV4cGxhbmF0aW9uIixtLmIsIm9mZnNl
-dCIsbS5jXSxrLHIpKX1qLlk1KDAsbyxuKX1yZXR1cm4gUC5FRihbInJlZ2lvbnMiLGwuYSwibmF2aWdh
-dGlvbkNvbnRlbnQiLGwuYiwic291cmNlQ29kZSIsbC5jLCJlZGl0cyIsal0sayxyKX19ClQubVEucHJv
-dG90eXBlPXt9CkwuZS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvLG4sbQp0
-LmFMLmEoYSkKcz13aW5kb3cubG9jYXRpb24ucGF0aG5hbWUKcj1MLkc2KHdpbmRvdy5sb2NhdGlvbi5o
-cmVmKQpxPUwuYUsod2luZG93LmxvY2F0aW9uLmhyZWYpCkwuR2UoKQppZihzIT09Ii8iJiZzIT09Si5U
-MChkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucm9vdCIpLnRleHRDb250ZW50KSlMLkc3KHMscixxLCEw
-LG5ldyBMLlZXKHMscixxKSkKcD1kb2N1bWVudApvPUoucUYocC5xdWVyeVNlbGVjdG9yKCIuYXBwbHkt
-bWlncmF0aW9uIikpCm49by4kdGkKbT1uLkMoIn4oMSk/IikuYShuZXcgTC5vWigpKQp0LlouYShudWxs
-KQpXLkpFKG8uYSxvLmIsbSwhMSxuLmMpCm49Si5xRihwLnF1ZXJ5U2VsZWN0b3IoIi5yZXJ1bi1taWdy
-YXRpb24iKSkKbT1uLiR0aQpXLkpFKG4uYSxuLmIsbS5DKCJ+KDEpPyIpLmEobmV3IEwuSGkoKSksITEs
-bS5jKQptPUoucUYocC5xdWVyeVNlbGVjdG9yKCIucmVwb3J0LXByb2JsZW0iKSkKbj1tLiR0aQpXLkpF
-KG0uYSxtLmIsbi5DKCJ+KDEpPyIpLmEobmV3IEwuQlQoKSksITEsbi5jKQpwPUoucUYocC5xdWVyeVNl
-bGVjdG9yKCIucG9wdXAtcGFuZSAuY2xvc2UiKSkKbj1wLiR0aQpXLkpFKHAuYSxwLmIsbi5DKCJ+KDEp
-PyIpLmEobmV3IEwuUFkoKSksITEsbi5jKQpuPUoucUYoJC5jMCgpKQpwPW4uJHRpClcuSkUobi5hLG4u
-YixwLkMoIn4oMSk/IikuYShuZXcgTC51OCgpKSwhMSxwLmMpfSwKJFM6MTh9CkwuVlcucHJvdG90eXBl
-PXsKJDA6ZnVuY3Rpb24oKXtMLkZyKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjJ9Ckwub1oucHJv
-dG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbwp0Lk8uYShhKQppZihILm9UKEMub2wu
-dXMod2luZG93LCJUaGlzIHdpbGwgYXBwbHkgdGhlIGNoYW5nZXMgeW91J3ZlIHByZXZpZXdlZCB0byB5
-b3VyIHdvcmtpbmcgZGlyZWN0b3J5LiBJdCBpcyByZWNvbW1lbmRlZCB5b3UgY29tbWl0IGFueSBjaGFu
-Z2VzIHlvdSBtYWRlIGJlZm9yZSBkb2luZyB0aGlzLiIpKSl7cz1ILlZNKFtdLHQuRykKZm9yKHI9JC5J
-UixxPXIubGVuZ3RoLHA9MDtwPHIubGVuZ3RoO3IubGVuZ3RoPT09cXx8KDAsSC5saykociksKytwKXMu
-cHVzaChyW3BdLkx0KCkpCnM9TC50eSgiL2FwcGx5LW1pZ3JhdGlvbiIsUC5FRihbIm5hdmlnYXRpb25U
-cmVlIixzXSx0LlgsdC5kcCkpLlc3KG5ldyBMLmpyKCksdC5QKQpvPW5ldyBMLnFsKCkKdC5iNy5hKG51
-bGwpCnI9cy4kdGkKcT0kLlgzCmlmKHEhPT1DLk5VKW89UC5WSChvLHEpCnMueGYobmV3IFAuRmUobmV3
-IFAudnMocSxyKSwyLG51bGwsbyxyLkMoIkA8MT4iKS5LcShyLmMpLkMoIkZlPDEsMj4iKSkpfX0sCiRT
-OjF9CkwuanIucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC50LmEoYSkKcz1kb2N1bWVu
-dC5ib2R5CnMuY2xhc3NMaXN0LnJlbW92ZSgicHJvcG9zZWQiKQpzLmNsYXNzTGlzdC5hZGQoImFwcGxp
-ZWQiKX0sCiRTOjQzfQpMLnFsLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7TC5DMigiQ291bGQg
-bm90IGFwcGx5IG1pZ3JhdGlvbiIsYSxiKX0sCiRDOiIkMiIsCiRSOjIsCiRTOjE2fQpMLkhpLnByb3Rv
-dHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLnhuKHQuTy5hKGEpKX0sCnhuOmZ1bmN0aW9u
-KGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuLG0sbCxrLGoKdmFyICRhc3luYyQkMT1Q
-Lmx6KGZ1bmN0aW9uKGIsYyl7aWYoYj09PTEpe3A9YwpzPXF9d2hpbGUodHJ1ZSlzd2l0Y2gocyl7Y2Fz
-ZSAwOnE9Mwpkb2N1bWVudC5ib2R5LmNsYXNzTGlzdC5hZGQoInJlcnVubmluZyIpCnM9NgpyZXR1cm4g
-UC5qUShMLnR5KCIvcmVydW4tbWlncmF0aW9uIixudWxsKSwkYXN5bmMkJDEpCmNhc2UgNjpuPWMKaWYo
-SC5vVChILnk4KEoueDkobiwic3VjY2VzcyIpKSkpd2luZG93LmxvY2F0aW9uLnJlbG9hZCgpCmVsc2Ug
-TC5LMCh0Lm0uYShKLng5KG4sImVycm9ycyIpKSkKby5wdXNoKDUpCnM9NApicmVhawpjYXNlIDM6cT0y
-Cmo9cAptPUguUnUoaikKbD1ILnRzKGopCkwuQzIoIkZhaWxlZCB0byByZXJ1biBtaWdyYXRpb24iLG0s
-bCkKby5wdXNoKDUpCnM9NApicmVhawpjYXNlIDI6bz1bMV0KY2FzZSA0OnE9MQpkb2N1bWVudC5ib2R5
-LmNsYXNzTGlzdC5yZW1vdmUoInJlcnVubmluZyIpCnM9by5wb3AoKQpicmVhawpjYXNlIDU6cmV0dXJu
-IFAueUMobnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMk
-JDEscil9LAokUzoxOX0KTC5CVC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShh
-KQpzPXQuWApDLm9sLlBvKHdpbmRvdyxQLlhkKCJodHRwcyIsImdpdGh1Yi5jb20iLCJkYXJ0LWxhbmcv
-c2RrL2lzc3Vlcy9uZXciLFAuRUYoWyJ0aXRsZSIsIkN1c3RvbWVyLXJlcG9ydGVkIGlzc3VlIHdpdGgg
-Tk5CRCBtaWdyYXRpb24gdG9vbCIsImxhYmVscyIsdS5kLCJib2R5IiwiIyMjIyBTdGVwcyB0byByZXBy
-b2R1Y2VcblxuIyMjIyBXaGF0IGRpZCB5b3UgZXhwZWN0IHRvIGhhcHBlbj9cblxuIyMjIyBXaGF0IGFj
-dHVhbGx5IGhhcHBlbmVkP1xuXG5fU2NyZWVuc2hvdHMgYXJlIGFwcHJlY2lhdGVkX1xuXG4qKkRhcnQg
-U0RLIHZlcnNpb24qKjogIitILkVqKGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzZGstdmVyc2lvbiIp
-LnRleHRDb250ZW50KSsiXG5cblRoYW5rcyBmb3IgZmlsaW5nIVxuIl0scyxzKSkuZ25EKCksInJlcG9y
-dC1wcm9ibGVtIil9LAokUzoxfQpMLlBZLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQu
-Ty5hKGEpCnM9ZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLnBvcHVwLXBhbmUiKS5zdHlsZQpzLmRpc3Bs
-YXk9Im5vbmUiCnJldHVybiJub25lIn0sCiRTOjQ1fQpMLnU4LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
-KGEpe3ZhciBzLHIscSxwCnQuTy5hKGEpCnM9JC5EOSgpLmlubmVyVGV4dApyPXQuZy5hKGRvY3VtZW50
-LnF1ZXJ5U2VsZWN0b3IoJy5uYXYtcGFuZWwgW2RhdGEtbmFtZSo9IicrSC5FaihzKSsnIl0nKS5wYXJl
-bnROb2RlKQpxPXIucXVlcnlTZWxlY3RvcigiLnN0YXR1cy1pY29uIikKcD1MLm1IKCQuSVIscykKaWYo
-cCBpbnN0YW5jZW9mIEwuY0Qpe0wuT3QocCkKTC54bihxLHApCkwuQVIocixwKX19LAokUzoxfQpMLkwu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuYUwuYShhKQpzPXdpbmRvdy5sb2Nh
-dGlvbi5wYXRobmFtZQpyPUwuRzYod2luZG93LmxvY2F0aW9uLmhyZWYpCnE9TC5hSyh3aW5kb3cubG9j
-YXRpb24uaHJlZikKaWYocy5sZW5ndGg+MSlMLkc3KHMscixxLCExLG51bGwpCmVsc2V7TC5CRShzLEIu
-d1IoKSwhMCkKTC5CWCgiJm5ic3A7IixudWxsKX19LAokUzoxOH0KTC5XeC5wcm90b3R5cGU9ewokMTpm
-dW5jdGlvbihhKXt2YXIgcyxyLHEscD0iY29sbGFwc2VkIgp0Lk8uYShhKQpzPXRoaXMuYQpyPUouWUUo
-cykKcT10aGlzLmIKaWYoIXIuZ24ocykudGcoMCxwKSl7ci5nbihzKS5pKDAscCkKSi5kUihxKS5pKDAs
-cCl9ZWxzZXtyLmduKHMpLkwoMCxwKQpKLmRSKHEpLkwoMCxwKX19LAokUzoxfQpMLkFPLnByb3RvdHlw
-ZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzPUoucUYodC5nLmEoYSkpLHI9cy4kdGkscT1yLkMoIn4oMSk/
-IikuYShuZXcgTC5kTih0aGlzLmEpKQp0LlouYShudWxsKQpXLkpFKHMuYSxzLmIscSwhMSxyLmMpfSwK
-JFM6M30KTC5kTi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcwp0Lk8uYShhKQpzPWRvY3Vt
-ZW50LnF1ZXJ5U2VsZWN0b3IoInRhYmxlW2RhdGEtcGF0aF0iKQpzLnRvU3RyaW5nCkwudDIoYSx0aGlz
-LmEscy5nZXRBdHRyaWJ1dGUoImRhdGEtIituZXcgVy5TeShuZXcgVy5pNyhzKSkuUCgicGF0aCIpKSl9
-LAokUzoxfQpMLkhvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscQp0LmcuYShhKQpz
-PUoucUYoYSkKcj1zLiR0aQpxPXIuQygifigxKT8iKS5hKG5ldyBMLnh6KGEsdGhpcy5hKSkKdC5aLmEo
-bnVsbCkKVy5KRShzLmEscy5iLHEsITEsci5jKX0sCiRTOjN9CkwueHoucHJvdG90eXBlPXsKJDE6ZnVu
-Y3Rpb24oYSl7dmFyIHMKdC5PLmEoYSkKcz10aGlzLmEKTC5oWCh0aGlzLmIsUC5RQShzLmdldEF0dHJp
-YnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5QKCJvZmZzZXQiKSksbnVsbCksUC5RQShz
-LmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5QKCJsaW5lIikpLG51bGwp
-KX0sCiRTOjF9CkwuSUMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHM9Si5xRih0LmcuYShh
-KSkscj1zLiR0aQpyLkMoIn4oMSk/IikuYShMLmlTKCkpCnQuWi5hKG51bGwpClcuSkUocy5hLHMuYixM
-LmlTKCksITEsci5jKX0sCiRTOjN9CkwuZkMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dC5lUS5h
-KGEpCnRoaXMuYS5hTSgwLHRoaXMuYil9LAokUzo0N30KTC5uVC5wcm90b3R5cGU9ewokMDpmdW5jdGlv
-bigpe0wuRnIodGhpcy5hLHRoaXMuYix0aGlzLmMpfSwKJFM6Mn0KTC5OWS5wcm90b3R5cGU9ewokMDpm
-dW5jdGlvbigpe0wuRnIodGhpcy5hLG51bGwsbnVsbCl9LAokUzoyfQpMLnVlLnByb3RvdHlwZT17CiQx
-OmZ1bmN0aW9uKGEpe3QuYXcuYShhKQpyZXR1cm4gSC5FaihhLnEoMCwic2V2ZXJpdHkiKSkrIiAtICIr
-SC5FaihhLnEoMCwibWVzc2FnZSIpKSsiIGF0ICIrSC5FaihhLnEoMCwibG9jYXRpb24iKSkrIiAtICgi
-K0guRWooYS5xKDAsImNvZGUiKSkrIikifSwKJFM6NDh9CkwuZVgucHJvdG90eXBlPXsKJDE6ZnVuY3Rp
-b24oYSl7dC5nLmEoYSkKJC56QigpLnRvU3RyaW5nCnQuZEguYSgkLm93KCkucSgwLCJobGpzIikpLlY3
-KCJoaWdobGlnaHRCbG9jayIsW2FdKX0sCiRTOjN9CkwuRUUucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24o
-YSl7dmFyIHMscgp0Lk8uYShhKS5wcmV2ZW50RGVmYXVsdCgpCnM9dGhpcy5hCnI9dGhpcy5iCkwuYWYo
-d2luZG93LmxvY2F0aW9uLnBhdGhuYW1lLHMsciwhMCxuZXcgTC5RTChzLHIpKQpMLmhYKHRoaXMuYyxz
-LHIpfSwKJFM6MX0KTC5RTC5wcm90b3R5cGU9ewokMDpmdW5jdGlvbigpe0wuRnIod2luZG93LmxvY2F0
-aW9uLnBhdGhuYW1lLHRoaXMuYSx0aGlzLmIpfSwKJFM6Mn0KTC5WUy5wcm90b3R5cGU9ewokMTpmdW5j
-dGlvbihhKXt2YXIgcyxyPSJzZWxlY3RlZC1maWxlIgp0LmcuYShhKQphLnRvU3RyaW5nCnM9Si5ZRShh
-KQppZihhLmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KGEpKS5QKCJuYW1lIikp
-PT09dGhpcy5hLmEpcy5nbihhKS5pKDAscikKZWxzZSBzLmduKGEpLkwoMCxyKX0sCiRTOjN9CkwuVEQu
-cHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEwudDIodC5PLmEoYSksITAsbnVsbCl9LAok
-UzoyMH0KTC5tMi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5SSSh0Lk8uYShh
-KSl9LApSSTpmdW5jdGlvbihhKXt2YXIgcz0wLHI9UC5GWCh0LlApLHE9MSxwLG89W10sbj10aGlzLG0s
-bCxrLGosaSxoLGcsZgp2YXIgJGFzeW5jJCQxPVAubHooZnVuY3Rpb24oYixjKXtpZihiPT09MSl7cD1j
-CnM9cX13aGlsZSh0cnVlKXN3aXRjaChzKXtjYXNlIDA6cT0zCmk9ZG9jdW1lbnQKbT1DLkNELnpRKGku
-cXVlcnlTZWxlY3RvcigiLmNvbnRlbnQiKS5zY3JvbGxUb3ApCmg9dC5YCnM9NgpyZXR1cm4gUC5qUShM
-LnR5KEwuUTQoIi9hcHBseS1oaW50IixQLkZsKGgsaCkpLG4uYS5MdCgpKSwkYXN5bmMkJDEpCmNhc2Ug
-NjpoPW4uYgpsPUwuVXMoaC5hKQpzPTcKcmV0dXJuIFAualEoTC5HNyhsLG51bGwsaC5iLCExLG51bGwp
-LCRhc3luYyQkMSkKY2FzZSA3OmkuYm9keS5jbGFzc0xpc3QuYWRkKCJuZWVkcy1yZXJ1biIpCmk9aS5x
-dWVyeVNlbGVjdG9yKCIuY29udGVudCIpCmkudG9TdHJpbmcKaS5zY3JvbGxUb3A9Si5WdShtKQpxPTEK
-cz01CmJyZWFrCmNhc2UgMzpxPTIKZj1wCms9SC5SdShmKQpqPUgudHMoZikKTC5DMigiQ291bGQgbm90
-IGFwcGx5IGhpbnQiLGssaikKcz01CmJyZWFrCmNhc2UgMjpzPTEKYnJlYWsKY2FzZSA1OnJldHVybiBQ
-LnlDKG51bGwscikKY2FzZSAxOnJldHVybiBQLmYzKHAscil9fSkKcmV0dXJuIFAuREkoJGFzeW5jJCQx
-LHIpfSwKJFM6MTl9CkwuWEEucHJvdG90eXBlPXsKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiEwfSwK
-aTA6ZnVuY3Rpb24oYSl7cmV0dXJuITB9LAokaWtGOjF9CkwudnQucHJvdG90eXBlPXsKZ2Q2OmZ1bmN0
-aW9uKCl7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzLmQKaWYobC5sZW5ndGg9PT0wKXJldHVybiBDLmN3
-CnM9Qy5ObS5ndEgobCkuZ2Q2KCkKZm9yKHI9bC5sZW5ndGgscT0hMCxwPSEwLG89MDtvPGwubGVuZ3Ro
-O2wubGVuZ3RoPT09cnx8KDAsSC5saykobCksKytvKXtuPWxbb10uZ2Q2KCkKaWYobiE9cylzPW51bGwK
-bT1uIT09Qy5jdwppZihtJiZuIT09Qy5XRClxPSExCmlmKG0mJm4hPT1DLlhqKXA9ITF9aWYocyE9bnVs
-bClyZXR1cm4gcwppZihxKXJldHVybiBDLldECmlmKHApcmV0dXJuIEMuWGoKcmV0dXJuIEMuZGN9LApM
-VjpmdW5jdGlvbigpe3ZhciBzLHIscT10aGlzLmQKaWYocSE9bnVsbClmb3Iocz1xLmxlbmd0aCxyPTA7
-cjxzOysrcilxW3JdLmI9dGhpc30sCkx0OmZ1bmN0aW9uKCl7dmFyIHMscj1QLkZsKHQuWCx0Ll8pCnIu
-WTUoMCwidHlwZSIsImRpcmVjdG9yeSIpCnIuWTUoMCwibmFtZSIsdGhpcy5hKQpyLlk1KDAsInN1YnRy
-ZWUiLEwuVkQodGhpcy5kKSkKcz10aGlzLmMKaWYocyE9bnVsbClyLlk1KDAsInBhdGgiLHMpCnJldHVy
-biByfX0KTC5jRC5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3ZhciBzLHI9dGhpcyxxPVAuRmwodC5Y
-LHQuXykKcS5ZNSgwLCJ0eXBlIiwiZmlsZSIpCnEuWTUoMCwibmFtZSIsci5hKQpzPXIuYwppZihzIT1u
-dWxsKXEuWTUoMCwicGF0aCIscykKcz1yLmQKaWYocyE9bnVsbClxLlk1KDAsImhyZWYiLHMpCnM9ci5l
-CmlmKHMhPW51bGwpcS5ZNSgwLCJlZGl0Q291bnQiLHMpCnM9ci5mCmlmKHMhPW51bGwpcS5ZNSgwLCJ3
-YXNFeHBsaWNpdGx5T3B0ZWRPdXQiLHMpCnM9ci5yCmlmKHMhPW51bGwpcS5ZNSgwLCJtaWdyYXRpb25T
-dGF0dXMiLHMuYSkKcmV0dXJuIHF9LApnZDY6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5yfX0KTC5EOC5w
-cm90b3R5cGU9e30KTC5POS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmJ9fQpM
-LkdiLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYn19Ck0ubEkucHJvdG90eXBl
-PXsKZ2w6ZnVuY3Rpb24oKXt2YXIgcz1ELmFiKCkKcmV0dXJuIHN9LApXTzpmdW5jdGlvbihhLGIpe3Zh
-ciBzLHIscT10LmQ0Ck0uWUYoImFic29sdXRlIixILlZNKFtiLG51bGwsbnVsbCxudWxsLG51bGwsbnVs
-bCxudWxsXSxxKSkKcz10aGlzLmEKcz1zLllyKGIpPjAmJiFzLmhLKGIpCmlmKHMpcmV0dXJuIGIKcj1I
-LlZNKFt0aGlzLmdsKCksYixudWxsLG51bGwsbnVsbCxudWxsLG51bGwsbnVsbF0scSkKTS5ZRigiam9p
-biIscikKcmV0dXJuIHRoaXMuSVAobmV3IEgudTYocix0LmVKKSl9LAp6ZjpmdW5jdGlvbihhKXt2YXIg
-cyxyLHE9WC5DTChhLHRoaXMuYSkKcS5JeCgpCnM9cS5kCnI9cy5sZW5ndGgKaWYocj09PTApe3M9cS5i
-CnJldHVybiBzPT1udWxsPyIuIjpzfWlmKHI9PT0xKXtzPXEuYgpyZXR1cm4gcz09bnVsbD8iLiI6c31p
-ZigwPj1yKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcz1xLmUKaWYoMD49cy5sZW5ndGgpcmV0dXJu
-IEguT0gocywtMSkKcy5wb3AoKQpxLkl4KCkKcmV0dXJuIHEudygwKX0sCklQOmZ1bmN0aW9uKGEpe3Zh
-ciBzLHIscSxwLG8sbixtLGwsayxqCnQuUS5hKGEpCmZvcihzPWEuJHRpLHI9cy5DKCJhMihjWC5FKSIp
-LmEobmV3IE0ucTcoKSkscT1hLmdtKGEpLHM9bmV3IEguU08ocSxyLHMuQygiU088Y1guRT4iKSkscj10
-aGlzLmEscD0hMSxvPSExLG49IiI7cy5GKCk7KXttPXEuZ2woKQppZihyLmhLKG0pJiZvKXtsPVguQ0wo
-bSxyKQprPW4uY2hhckNvZGVBdCgwKT09MD9uOm4Kbj1DLnhCLk5qKGssMCxyLlNwKGssITApKQpsLmI9
-bgppZihyLmRzKG4pKUMuTm0uWTUobC5lLDAsci5nbUkoKSkKbj1sLncoMCl9ZWxzZSBpZihyLllyKG0p
-PjApe289IXIuaEsobSkKbj1ILkVqKG0pfWVsc2V7aj1tLmxlbmd0aAppZihqIT09MCl7aWYoMD49aily
-ZXR1cm4gSC5PSChtLDApCmo9ci5VZChtWzBdKX1lbHNlIGo9ITEKaWYoIWopaWYocCluKz1yLmdtSSgp
-Cm4rPW19cD1yLmRzKG0pfXJldHVybiBuLmNoYXJDb2RlQXQoMCk9PTA/bjpufSwKbzU6ZnVuY3Rpb24o
-YSl7dmFyIHMKaWYoIXRoaXMueTMoYSkpcmV0dXJuIGEKcz1YLkNMKGEsdGhpcy5hKQpzLnJSKCkKcmV0
-dXJuIHMudygwKX0sCnkzOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqCmEudG9TdHJp
-bmcKcz10aGlzLmEKcj1zLllyKGEpCmlmKHIhPT0wKXtpZihzPT09JC5LaygpKWZvcihxPTA7cTxyOysr
-cSlpZihDLnhCLlcoYSxxKT09PTQ3KXJldHVybiEwCnA9cgpvPTQ3fWVsc2V7cD0wCm89bnVsbH1mb3Io
-bj1uZXcgSC5xaihhKS5hLG09bi5sZW5ndGgscT1wLGw9bnVsbDtxPG07KytxLGw9byxvPWspe2s9Qy54
-Qi5PMihuLHEpCmlmKHMucjQoaykpe2lmKHM9PT0kLktrKCkmJms9PT00NylyZXR1cm4hMAppZihvIT1u
-dWxsJiZzLnI0KG8pKXJldHVybiEwCmlmKG89PT00NilqPWw9PW51bGx8fGw9PT00Nnx8cy5yNChsKQpl
-bHNlIGo9ITEKaWYoailyZXR1cm4hMH19aWYobz09bnVsbClyZXR1cm4hMAppZihzLnI0KG8pKXJldHVy
-biEwCmlmKG89PT00NilzPWw9PW51bGx8fHMucjQobCl8fGw9PT00NgplbHNlIHM9ITEKaWYocylyZXR1
-cm4hMApyZXR1cm4hMX0sCkhQOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAsbyxuLG0sbD10aGlzLGs9
-J1VuYWJsZSB0byBmaW5kIGEgcGF0aCB0byAiJwpiPWwuV08oMCxiKQpzPWwuYQppZihzLllyKGIpPD0w
-JiZzLllyKGEpPjApcmV0dXJuIGwubzUoYSkKaWYocy5ZcihhKTw9MHx8cy5oSyhhKSlhPWwuV08oMCxh
-KQppZihzLllyKGEpPD0wJiZzLllyKGIpPjApdGhyb3cgSC5iKFguSTcoaytILkVqKGEpKyciIGZyb20g
-IicrSC5FaihiKSsnIi4nKSkKcj1YLkNMKGIscykKci5yUigpCnE9WC5DTChhLHMpCnEuclIoKQpwPXIu
-ZApvPXAubGVuZ3RoCmlmKG8hPT0wKXtpZigwPj1vKXJldHVybiBILk9IKHAsMCkKcD1KLlJNKHBbMF0s
-Ii4iKX1lbHNlIHA9ITEKaWYocClyZXR1cm4gcS53KDApCnA9ci5iCm89cS5iCmlmKHAhPW8pcD1wPT1u
-dWxsfHxvPT1udWxsfHwhcy5OYyhwLG8pCmVsc2UgcD0hMQppZihwKXJldHVybiBxLncoMCkKd2hpbGUo
-ITApe3A9ci5kCm89cC5sZW5ndGgKaWYobyE9PTApe249cS5kCm09bi5sZW5ndGgKaWYobSE9PTApe2lm
-KDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPXBbMF0KaWYoMD49bSlyZXR1cm4gSC5PSChuLDApCm49cy5O
-YyhwLG5bMF0pCnA9bn1lbHNlIHA9ITF9ZWxzZSBwPSExCmlmKCFwKWJyZWFrCkMuTm0uVzQoci5kLDAp
-CkMuTm0uVzQoci5lLDEpCkMuTm0uVzQocS5kLDApCkMuTm0uVzQocS5lLDEpfXA9ci5kCm89cC5sZW5n
-dGgKaWYobyE9PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPUouUk0ocFswXSwiLi4iKX1lbHNl
-IHA9ITEKaWYocCl0aHJvdyBILmIoWC5JNyhrK0guRWooYSkrJyIgZnJvbSAiJytILkVqKGIpKyciLicp
-KQpwPXQuTgpDLk5tLlVHKHEuZCwwLFAuTzgoci5kLmxlbmd0aCwiLi4iLCExLHApKQpDLk5tLlk1KHEu
-ZSwwLCIiKQpDLk5tLlVHKHEuZSwxLFAuTzgoci5kLmxlbmd0aCxzLmdtSSgpLCExLHApKQpzPXEuZApw
-PXMubGVuZ3RoCmlmKHA9PT0wKXJldHVybiIuIgppZihwPjEmJkouUk0oQy5ObS5ncloocyksIi4iKSl7
-cz1xLmQKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpzPXEuZQppZigwPj1z
-Lmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9I
-KHMsLTEpCnMucG9wKCkKQy5ObS5pKHMsIiIpfXEuYj0iIgpxLkl4KCkKcmV0dXJuIHEudygwKX19Ck0u
-cTcucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIEguaChhKSE9PSIifSwKJFM6Nn0KTS5O
-by5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtILmsoYSkKcmV0dXJuIGE9PW51bGw/Im51bGwiOici
-JythKyciJ30sCiRTOjUwfQpCLmZ2LnByb3RvdHlwZT17CnhaOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhp
-cy5ZcihhKQppZihyPjApcmV0dXJuIEoubGQoYSwwLHIpCmlmKHRoaXMuaEsoYSkpe2lmKDA+PWEubGVu
-Z3RoKXJldHVybiBILk9IKGEsMCkKcz1hWzBdfWVsc2Ugcz1udWxsCnJldHVybiBzfSwKTmM6ZnVuY3Rp
-b24oYSxiKXtyZXR1cm4gYT09Yn19ClguV0QucHJvdG90eXBlPXsKSXg6ZnVuY3Rpb24oKXt2YXIgcyxy
-LHE9dGhpcwp3aGlsZSghMCl7cz1xLmQKaWYoIShzLmxlbmd0aCE9PTAmJkouUk0oQy5ObS5ncloocyks
-IiIpKSlicmVhawpzPXEuZAppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnM9
-cS5lCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCl9cz1xLmUKcj1zLmxlbmd0
-aAppZihyIT09MClDLk5tLlk1KHMsci0xLCIiKX0sCnJSOmZ1bmN0aW9uKCl7dmFyIHMscixxLHAsbyxu
-LG09dGhpcyxsPUguVk0oW10sdC5zKQpmb3Iocz1tLmQscj1zLmxlbmd0aCxxPTAscD0wO3A8cy5sZW5n
-dGg7cy5sZW5ndGg9PT1yfHwoMCxILmxrKShzKSwrK3Ape289c1twXQpuPUouaWEobykKaWYoIShuLkRO
-KG8sIi4iKXx8bi5ETihvLCIiKSkpaWYobi5ETihvLCIuLiIpKXtuPWwubGVuZ3RoCmlmKG4hPT0wKXtp
-ZigwPj1uKXJldHVybiBILk9IKGwsLTEpCmwucG9wKCl9ZWxzZSArK3F9ZWxzZSBDLk5tLmkobCxvKX1p
-ZihtLmI9PW51bGwpQy5ObS5VRyhsLDAsUC5POChxLCIuLiIsITEsdC5OKSkKaWYobC5sZW5ndGg9PT0w
-JiZtLmI9PW51bGwpQy5ObS5pKGwsIi4iKQptLnNuSihsKQpzPW0uYQptLnNQaChQLk84KGwubGVuZ3Ro
-KzEscy5nbUkoKSwhMCx0Lk4pKQpyPW0uYgppZihyPT1udWxsfHxsLmxlbmd0aD09PTB8fCFzLmRzKHIp
-KUMuTm0uWTUobS5lLDAsIiIpCnI9bS5iCmlmKHIhPW51bGwmJnM9PT0kLktrKCkpe3IudG9TdHJpbmcK
-bS5iPUgueXMociwiLyIsIlxcIil9bS5JeCgpfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyLHE9dGhpcyxw
-PXEuYgpwPXAhPW51bGw/cDoiIgpmb3Iocz0wO3M8cS5kLmxlbmd0aDsrK3Mpe3I9cS5lCmlmKHM+PXIu
-bGVuZ3RoKXJldHVybiBILk9IKHIscykKcj1wK0guRWoocltzXSkKcD1xLmQKaWYocz49cC5sZW5ndGgp
-cmV0dXJuIEguT0gocCxzKQpwPXIrSC5FaihwW3NdKX1wKz1ILkVqKEMuTm0uZ3JaKHEuZSkpCnJldHVy
-biBwLmNoYXJDb2RlQXQoMCk9PTA/cDpwfSwKc25KOmZ1bmN0aW9uKGEpe3RoaXMuZD10LkUuYShhKX0s
-CnNQaDpmdW5jdGlvbihhKXt0aGlzLmU9dC5FLmEoYSl9fQpYLmR2LnByb3RvdHlwZT17Cnc6ZnVuY3Rp
-b24oYSl7cmV0dXJuIlBhdGhFeGNlcHRpb246ICIrdGhpcy5hfSwKJGlSejoxfQpPLnpMLnByb3RvdHlw
-ZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ29jKHRoaXMpfX0KRS5PRi5wcm90b3R5cGU9ewpV
-ZDpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihhKXtyZXR1cm4g
-YT09PTQ3fSwKZHM6ZnVuY3Rpb24oYSl7dmFyIHM9YS5sZW5ndGgKcmV0dXJuIHMhPT0wJiZDLnhCLk8y
-KGEscy0xKSE9PTQ3fSwKU3A6ZnVuY3Rpb24oYSxiKXtpZihhLmxlbmd0aCE9PTAmJkMueEIuVyhhLDAp
-PT09NDcpcmV0dXJuIDEKcmV0dXJuIDB9LApZcjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5TcChhLCEx
-KX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiExfSwKZ29jOmZ1bmN0aW9uKCl7cmV0dXJuInBvc2l4In0s
-CmdtSTpmdW5jdGlvbigpe3JldHVybiIvIn19CkYucnUucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7
-cmV0dXJuIEMueEIudGcoYSwiLyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N30sCmRzOmZ1
-bmN0aW9uKGEpe3ZhciBzPWEubGVuZ3RoCmlmKHM9PT0wKXJldHVybiExCmlmKEMueEIuTzIoYSxzLTEp
-IT09NDcpcmV0dXJuITAKcmV0dXJuIEMueEIuVGMoYSwiOi8vIikmJnRoaXMuWXIoYSk9PT1zfSwKU3A6
-ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvPWEubGVuZ3RoCmlmKG89PT0wKXJldHVybiAwCmlmKEMu
-eEIuVyhhLDApPT09NDcpcmV0dXJuIDEKZm9yKHM9MDtzPG87KytzKXtyPUMueEIuVyhhLHMpCmlmKHI9
-PT00NylyZXR1cm4gMAppZihyPT09NTgpe2lmKHM9PT0wKXJldHVybiAwCnE9Qy54Qi5YVShhLCIvIixD
-LnhCLlFpKGEsIi8vIixzKzEpP3MrMzpzKQppZihxPD0wKXJldHVybiBvCmlmKCFifHxvPHErMylyZXR1
-cm4gcQppZighQy54Qi5uQyhhLCJmaWxlOi8vIikpcmV0dXJuIHEKaWYoIUIuWXUoYSxxKzEpKXJldHVy
-biBxCnA9cSszCnJldHVybiBvPT09cD9wOnErNH19cmV0dXJuIDB9LApZcjpmdW5jdGlvbihhKXtyZXR1
-cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aCE9PTAmJkMueEIu
-VyhhLDApPT09NDd9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4idXJsIn0sCmdtSTpmdW5jdGlvbigpe3Jl
-dHVybiIvIn19CkwuSVYucHJvdG90eXBlPXsKVWQ6ZnVuY3Rpb24oYSl7cmV0dXJuIEMueEIudGcoYSwi
-LyIpfSwKcjQ6ZnVuY3Rpb24oYSl7cmV0dXJuIGE9PT00N3x8YT09PTkyfSwKZHM6ZnVuY3Rpb24oYSl7
-dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKcz1DLnhCLk8yKGEscy0xKQpyZXR1cm4hKHM9
-PT00N3x8cz09PTkyKX0sClNwOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxPWEubGVuZ3RoCmlmKHE9PT0w
-KXJldHVybiAwCnM9Qy54Qi5XKGEsMCkKaWYocz09PTQ3KXJldHVybiAxCmlmKHM9PT05Mil7aWYocTwy
-fHxDLnhCLlcoYSwxKSE9PTkyKXJldHVybiAxCnI9Qy54Qi5YVShhLCJcXCIsMikKaWYocj4wKXtyPUMu
-eEIuWFUoYSwiXFwiLHIrMSkKaWYocj4wKXJldHVybiByfXJldHVybiBxfWlmKHE8MylyZXR1cm4gMApp
-ZighQi5PUyhzKSlyZXR1cm4gMAppZihDLnhCLlcoYSwxKSE9PTU4KXJldHVybiAwCnE9Qy54Qi5XKGEs
-MikKaWYoIShxPT09NDd8fHE9PT05MikpcmV0dXJuIDAKcmV0dXJuIDN9LApZcjpmdW5jdGlvbihhKXty
-ZXR1cm4gdGhpcy5TcChhLCExKX0sCmhLOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLllyKGEpPT09MX0s
-Ck90OmZ1bmN0aW9uKGEsYil7dmFyIHMKaWYoYT09PWIpcmV0dXJuITAKaWYoYT09PTQ3KXJldHVybiBi
-PT09OTIKaWYoYT09PTkyKXJldHVybiBiPT09NDcKaWYoKGFeYikhPT0zMilyZXR1cm4hMQpzPWF8MzIK
-cmV0dXJuIHM+PTk3JiZzPD0xMjJ9LApOYzpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQppZihhPT1iKXJl
-dHVybiEwCnM9YS5sZW5ndGgKaWYocyE9PWIubGVuZ3RoKXJldHVybiExCmZvcihyPUouclkoYikscT0w
-O3E8czsrK3EpaWYoIXRoaXMuT3QoQy54Qi5XKGEscSksci5XKGIscSkpKXJldHVybiExCnJldHVybiEw
-fSwKZ29jOmZ1bmN0aW9uKCl7cmV0dXJuIndpbmRvd3MifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJuIlxc
-In19OyhmdW5jdGlvbiBhbGlhc2VzKCl7dmFyIHM9Si5Hdi5wcm90b3R5cGUKcy5VPXMudwpzLlNqPXMu
-ZTcKcz1KLk1GLnByb3RvdHlwZQpzLnQ9cy53CnM9UC5jWC5wcm90b3R5cGUKcy5HRz1zLmV2CnM9UC5N
-aC5wcm90b3R5cGUKcy54Yj1zLncKcz1XLmN2LnByb3RvdHlwZQpzLkRXPXMucjYKcz1XLm02LnByb3Rv
-dHlwZQpzLmpGPXMuRWIKcz1QLkU0LnByb3RvdHlwZQpzLlVyPXMucQpzLmU0PXMuWTV9KSgpOyhmdW5j
-dGlvbiBpbnN0YWxsVGVhck9mZnMoKXt2YXIgcz1odW5rSGVscGVycy5fc3RhdGljXzEscj1odW5rSGVs
-cGVycy5fc3RhdGljXzAscT1odW5rSGVscGVycy5pbnN0YWxsSW5zdGFuY2VUZWFyT2ZmLHA9aHVua0hl
-bHBlcnMuaW5zdGFsbFN0YXRpY1RlYXJPZmYsbz1odW5rSGVscGVycy5faW5zdGFuY2VfMXUKcyhQLCJF
-WCIsIlpWIiw3KQpzKFAsInl0Iiwib0EiLDcpCnMoUCwicVciLCJCeiIsNykKcihQLCJVSSIsImVOIiww
-KQpxKFAuUGYucHJvdG90eXBlLCJnWUoiLDAsMSxudWxsLFsiJDIiLCIkMSJdLFsidzAiLCJwbSJdLDI4
-LDApCnMoUCwiQ3kiLCJOQyIsNCkKcyhQLCJQSCIsIk10Iiw1KQpwKFcsInBTIiw0LG51bGwsWyIkNCJd
-LFsicUQiXSw4LDApCnAoVywiVjQiLDQsbnVsbCxbIiQ0Il0sWyJRVyJdLDgsMCkKbyhQLkFzLnByb3Rv
-dHlwZSwiZ3VNIiwiViIsNSkKcyhQLCJpRyIsIndZIiw1MykKcyhQLCJ3MCIsImRVIiwzNikKcyhMLCJp
-UyIsImk2IiwyMCl9KSgpOyhmdW5jdGlvbiBpbmhlcml0YW5jZSgpe3ZhciBzPWh1bmtIZWxwZXJzLm1p
-eGluLHI9aHVua0hlbHBlcnMuaW5oZXJpdCxxPWh1bmtIZWxwZXJzLmluaGVyaXRNYW55CnIoUC5NaCxu
-dWxsKQpxKFAuTWgsW0guRkssSi5HdixKLm0xLFAuY1gsSC5FNyxQLlhTLFAublksSC5hNyxQLkFuLEgu
-RnUsSC5KQixILlNVLEguUmUsSC53dixQLlBuLEguV1UsSC5MSSxILlRwLEguZjksSC50ZSxILmJxLEgu
-WE8sSC5rcixQLllrLEgudmgsSC5ONixILlZSLEguRUssSC5QYixILnRRLEguU2QsSC5KYyxILkcsSC5s
-WSxQLlczLFAuaWgsUC5GeSxQLkdWLFAuUGYsUC5GZSxQLnZzLFAuT00sUC5xaCxQLk1PLFAua1QsUC54
-SSxQLkN3LFAubTAsUC5wUixQLmJuLFAubG0sUC5sRCxQLktQLFAubGYsUC5XWSxQLlVrLFAuU2gsUC5S
-dyxQLmJ6LFAuaVAsUC5rNSxQLktZLFAuQ0QsUC5hRSxQLk4zLFAuYzgsUC5aZCxQLlJuLFAuRG4sUC5Q
-RSxQLlVmLFcuaWQsVy5GayxXLkpRLFcuR20sVy52RCxXLm02LFcuT3csVy5XOSxXLmRXLFcubWssVy5L
-byxQLmlKLFAuRTQsTS5INyxVLkxMLFUuZDIsVS5TZSxVLk1sLFUueUQsVS53YixCLmo4LEIucXAsVC5t
-USxMLlhBLEwuRDgsTC5POSxMLkdiLE0ubEksTy56TCxYLldELFguZHZdKQpxKEouR3YsW0oueUUsSi53
-ZSxKLk1GLEouamQsSi5xSSxKLkRyLEguRVQsVy5EMCxXLkF6LFcuTGUsVy5OaCxXLmFlLFcuSUIsVy5u
-NyxXLmVhLFcuYnIsVy5TZyxXLnc3LFcuSzcsVy5YVyxQLmhGXSkKcShKLk1GLFtKLmlDLEoua2QsSi5j
-NV0pCnIoSi5QbyxKLmpkKQpxKEoucUksW0ouYlUsSi5WQV0pCnEoUC5jWCxbSC5CUixILmJRLEguaTEs
-SC5VNSxILkFNLEgudTYsSC5YUixQLm1XLEgudW5dKQpxKEguQlIsW0guWnksSC5RQ10pCnIoSC5vbCxI
-Llp5KQpyKEguVXEsSC5RQykKcihILmpWLEguVXEpCnEoUC5YUyxbSC5uLEgucjMsSC5HTSxQLkV6LEgu
-YXosSC52VixILkVxLFAuQzYsSC5rUyxQLlVkLFAuRixQLnUsUC5tcCxQLnViLFAuZHMsUC5saixQLlVW
-LFAuY10pCnIoUC51eSxQLm5ZKQpxKFAudXksW0gudzIsVy53eixXLmU3XSkKcihILnFqLEgudzIpCnEo
-SC5iUSxbSC5hTCxILk1CLEguaTVdKQpxKEguYUwsW0gubkgsSC5sSixQLmk4XSkKcihILnh5LEguaTEp
-CnEoUC5BbixbSC5NSCxILlNPLEguVTFdKQpyKEguZDUsSC5BTSkKcihQLlJVLFAuUG4pCnIoUC5HaixQ
-LlJVKQpyKEguUEQsUC5HaikKcihILkxQLEguV1UpCnEoSC5UcCxbSC5DaixILmxjLEguZEMsSC53TixI
-LlZYLFAudGgsUC5oYSxQLlZzLFAuRnQsUC55SCxQLldNLFAuU1gsUC5HcyxQLmRhLFAub1EsUC5wVixQ
-LlU3LFAudnIsUC5ydCxQLktGLFAuWkwsUC5SVCxQLmpaLFAucnEsUC5SVyxQLkI1LFAudU8sUC5wSyxQ
-LmhqLFAuVnAsUC5PUixQLnJhLFAueVEsUC5wZyxQLmMyLFAudGksUC5XRixQLm4xLFAuY1MsUC5WQyxQ
-LkpULFAuUlosUC5NRSxQLnk1LFAueUksUC5jNixQLnFkLFcuQ3YsVy5LUyxXLkEzLFcudk4sVy5VdixX
-LkVnLFcuRW8sVy5XayxXLklBLFcuZm0sUC5qZyxQLlRhLFAuR0UsUC5ONyxQLnVRLFAuUEMsUC5tdCxQ
-Lk56LFAuUVMsUC5ucCxVLk1ELFUuYU4sVS5iMCxMLmUsTC5WVyxMLm9aLEwuanIsTC5xbCxMLkhpLEwu
-QlQsTC5QWSxMLnU4LEwuTCxMLld4LEwuQU8sTC5kTixMLkhvLEwueHosTC5JQyxMLmZDLEwublQsTC5O
-WSxMLnVlLEwuZVgsTC5FRSxMLlFMLEwuVlMsTC5URCxMLm0yLE0ucTcsTS5Ob10pCnIoSC5XMCxQLkV6
-KQpxKEgubGMsW0guengsSC5yVF0pCnIoSC5rWSxQLkM2KQpyKFAuaWwsUC5ZaykKcShQLmlsLFtILk41
-LFAudXcsVy5jZixXLlN5XSkKcShQLm1XLFtILktXLFAucTRdKQpyKEguTFosSC5FVCkKcShILkxaLFtI
-LlJHLEguV0JdKQpyKEguVlAsSC5SRykKcihILkRnLEguVlApCnIoSC5aRyxILldCKQpyKEguUGcsSC5a
-RykKcShILlBnLFtILnhqLEguZEUsSC5aQSxILmRULEguUHEsSC5lRSxILlY2XSkKcihILmlNLEgua1Mp
-CnIoUC5aZixQLlBmKQpyKFAuSmksUC5tMCkKcihQLlh2LFAucFIpCnIoUC5iNixQLlh2KQpyKFAuVmos
-UC5XWSkKcShQLlVrLFtQLkNWLFAuWmksUC5ieV0pCnIoUC53SSxQLmtUKQpxKFAud0ksW1AuVTgsUC5v
-aixQLk14LFAuRTMsUC5HWV0pCnIoUC5LOCxQLlVkKQpyKFAudHUsUC5TaCkKcihQLnU1LFAuWmkpCnEo
-UC51LFtQLmJKLFAuZVldKQpyKFAucWUsUC5EbikKcShXLkQwLFtXLnVILFcud2EsVy5LNSxXLkNtXSkK
-cShXLnVILFtXLmN2LFcubngsVy5RRixXLkNRXSkKcShXLmN2LFtXLnFFLFAuaGldKQpxKFcucUUsW1cu
-R2gsVy5mWSxXLm5CLFcuUVAsVy5oNCxXLlNOLFcubHAsVy5UYixXLkl2LFcuV1AsVy55WV0pCnIoVy5v
-SixXLkxlKQpyKFcuaEgsVy5BeikKcihXLlZiLFcuUUYpCnIoVy5mSixXLndhKQpxKFcuZWEsW1cudzYs
-Vy5ld10pCnIoVy5BaixXLnc2KQpyKFcuckIsVy5LNykKcihXLkJILFcuckIpCnIoVy53NCxXLklCKQpy
-KFcub2EsVy5YVykKcihXLnJoLFcub2EpCnIoVy5pNyxXLmNmKQpyKFAuQXMsUC5WaikKcShQLkFzLFtX
-Lkk0LFAuS2VdKQpyKFcuUk8sUC5xaCkKcihXLmV1LFcuUk8pCnIoVy54QyxQLk1PKQpyKFcuY3QsVy5t
-NikKcihQLkJmLFAuaUopCnEoUC5FNCxbUC5yNyxQLmNvXSkKcihQLlR6LFAuY28pCnIoUC5uZCxQLmhp
-KQpxKEwuRDgsW0wudnQsTC5jRF0pCnIoQi5mdixPLnpMKQpxKEIuZnYsW0UuT0YsRi5ydSxMLklWXSkK
-cyhILncyLEguUmUpCnMoSC5RQyxQLmxEKQpzKEguUkcsUC5sRCkKcyhILlZQLEguU1UpCnMoSC5XQixQ
-LmxEKQpzKEguWkcsSC5TVSkKcyhQLm5ZLFAubEQpCnMoUC5XWSxQLmxmKQpzKFAuUlUsUC5LUCkKcyhQ
-LnBSLFAubGYpCnMoVy5MZSxXLmlkKQpzKFcuSzcsUC5sRCkKcyhXLnJCLFcuR20pCnMoVy5YVyxQLmxE
-KQpzKFcub2EsVy5HbSkKcyhQLmNvLFAubEQpfSkoKQp2YXIgdj17dHlwZVVuaXZlcnNlOntlQzpuZXcg
-TWFwKCksdFI6e30sZVQ6e30sdFBWOnt9LHNFQTpbXX0sbWFuZ2xlZEdsb2JhbE5hbWVzOntJZjoiaW50
-IixDUDoiZG91YmxlIixaWjoibnVtIixxVToiU3RyaW5nIixhMjoiYm9vbCIsYzg6Ik51bGwiLHpNOiJM
-aXN0In0sbWFuZ2xlZE5hbWVzOnt9LGdldFR5cGVGcm9tTmFtZTpnZXRHbG9iYWxGcm9tTmFtZSxtZXRh
-ZGF0YTpbXSx0eXBlczpbIn4oKSIsImM4KEFqKikiLCJjOCgpIiwiYzgoY3YqKSIsIkAoQCkiLCJxVShx
-VSkiLCJhMihxVSkiLCJ+KH4oKSkiLCJhMihjdixxVSxxVSxKUSkiLCJjOChAKSIsIn4oTWg/LE1oPyki
-LCJAKCkiLCJ+KHFVLEApIiwifihuNixxVSxJZikiLCJ+KHFVLHFVKSIsImEyKGtGKSIsImM4KEAsQCki
-LCJ+KHh1PHFVPikiLCJjOChlYSopIiwiYjg8Yzg+KihBaiopIiwifihBaiopIiwifihxVSxJZikiLCJ+
-KHFVLHFVPykiLCJuNihALEApIiwiYzgoQCxHeikiLCJhMih1SCkiLCJ+KElmLEApIiwifihlYSkiLCJ+
-KE1oW0d6P10pIiwiYzgoTWgsR3opIiwifih1SCx1SD8pIiwifihALEApIiwidnM8QD4oQCkiLCJhMih4
-dTxxVT4pIiwiYzgofigpKSIsInI3KEApIiwiTWg/KEApIiwiRTQoQCkiLCJhMiooSDcqKSIsIkxMKihA
-KSIsIlowPHFVKixNaCo+KihMTCopIiwiQChxVSkiLCJ+KEdELEApIiwiYzgoWjA8cVUqLE1oKj4qKSIs
-IlowPHFVLHFVPihaMDxxVSxxVT4scVUpIiwicVUqKEFqKikiLCJAKEAscVUpIiwiYzgoZXcqKSIsInFV
-KihaMDxALEA+KikiLCJ+KHFVW0BdKSIsInFVKHFVPykiLCJJZihJZixJZikiLCJ+KEApIiwiTWg/KE1o
-PykiLCJUejxAPihAKSJdLGludGVyY2VwdG9yc0J5VGFnOm51bGwsbGVhZlRhZ3M6bnVsbCxhcnJheVJ0
-aTp0eXBlb2YgU3ltYm9sPT0iZnVuY3Rpb24iJiZ0eXBlb2YgU3ltYm9sKCk9PSJzeW1ib2wiP1N5bWJv
-bCgiJHRpIik6IiR0aSJ9CkgueGIodi50eXBlVW5pdmVyc2UsSlNPTi5wYXJzZSgneyJjNSI6Ik1GIiwi
-aUMiOiJNRiIsImtkIjoiTUYiLCJyeCI6ImVhIiwiZTUiOiJlYSIsIlkwIjoiaGkiLCJ0cCI6ImhpIiwi
-RzgiOiJldyIsIk1yIjoicUUiLCJlTCI6InFFIiwiSTAiOiJ1SCIsImhzIjoidUgiLCJYZyI6IlFGIiwi
-bnIiOiJBaiIsInk0IjoidzYiLCJhUCI6IkNtIiwieGMiOiJueCIsImtKIjoibngiLCJ6VSI6IkRnIiwi
-ZGYiOiJFVCIsInlFIjp7ImEyIjpbXX0sIndlIjp7ImM4IjpbXX0sIk1GIjp7InZtIjpbXSwiRUgiOltd
-fSwiamQiOnsiek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIlBvIjp7ImpkIjpbIjEiXSwi
-ek0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIm0xIjp7IkFuIjpbIjEiXX0sInFJIjp7IkNQ
-IjpbXSwiWloiOltdfSwiYlUiOnsiQ1AiOltdLCJJZiI6W10sIlpaIjpbXX0sIlZBIjp7IkNQIjpbXSwi
-WloiOltdfSwiRHIiOnsicVUiOltdLCJ2WCI6W119LCJCUiI6eyJjWCI6WyIyIl19LCJFNyI6eyJBbiI6
-WyIyIl19LCJaeSI6eyJCUiI6WyIxIiwiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIm9sIjp7Ilp5
-IjpbIjEiLCIyIl0sIkJSIjpbIjEiLCIyIl0sImJRIjpbIjIiXSwiY1giOlsiMiJdLCJjWC5FIjoiMiJ9
-LCJVcSI6eyJsRCI6WyIyIl0sInpNIjpbIjIiXSwiQlIiOlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJjWCI6
-WyIyIl19LCJqViI6eyJVcSI6WyIxIiwiMiJdLCJsRCI6WyIyIl0sInpNIjpbIjIiXSwiQlIiOlsiMSIs
-IjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImxELkUiOiIyIiwiY1guRSI6IjIifSwibiI6eyJYUyI6
-W119LCJyMyI6eyJYUyI6W119LCJxaiI6eyJsRCI6WyJJZiJdLCJSZSI6WyJJZiJdLCJ6TSI6WyJJZiJd
-LCJiUSI6WyJJZiJdLCJjWCI6WyJJZiJdLCJsRC5FIjoiSWYiLCJSZS5FIjoiSWYifSwiR00iOnsiWFMi
-OltdfSwiYlEiOnsiY1giOlsiMSJdfSwiYUwiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJuSCI6eyJh
-TCI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdLCJhTC5FIjoiMSIsImNYLkUiOiIxIn0sImE3Ijp7
-IkFuIjpbIjEiXX0sImkxIjp7ImNYIjpbIjIiXSwiY1guRSI6IjIifSwieHkiOnsiaTEiOlsiMSIsIjIi
-XSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIk1IIjp7IkFuIjpbIjIiXX0sImxKIjp7
-ImFMIjpbIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImFMLkUiOiIyIiwiY1guRSI6IjIifSwiVTUi
-OnsiY1giOlsiMSJdLCJjWC5FIjoiMSJ9LCJTTyI6eyJBbiI6WyIxIl19LCJBTSI6eyJjWCI6WyIxIl0s
-ImNYLkUiOiIxIn0sImQ1Ijp7IkFNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIx
-In0sIlUxIjp7IkFuIjpbIjEiXX0sIk1CIjp7ImJRIjpbIjEiXSwiY1giOlsiMSJdLCJjWC5FIjoiMSJ9
-LCJGdSI6eyJBbiI6WyIxIl19LCJ1NiI6eyJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkpCIjp7IkFuIjpb
-IjEiXX0sIncyIjp7ImxEIjpbIjEiXSwiUmUiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiY1gi
-OlsiMSJdfSwid3YiOnsiR0QiOltdfSwiUEQiOnsiR2oiOlsiMSIsIjIiXSwiUlUiOlsiMSIsIjIiXSwi
-UG4iOlsiMSIsIjIiXSwiS1AiOlsiMSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIldVIjp7IlowIjpbIjEi
-LCIyIl19LCJMUCI6eyJXVSI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiWFIiOnsiY1giOlsiMSJd
-LCJjWC5FIjoiMSJ9LCJMSSI6eyJ2USI6W119LCJXMCI6eyJYUyI6W119LCJheiI6eyJYUyI6W119LCJ2
-ViI6eyJYUyI6W119LCJ0ZSI6eyJSeiI6W119LCJYTyI6eyJHeiI6W119LCJUcCI6eyJFSCI6W119LCJs
-YyI6eyJFSCI6W119LCJ6eCI6eyJFSCI6W119LCJyVCI6eyJFSCI6W119LCJFcSI6eyJYUyI6W119LCJr
-WSI6eyJYUyI6W119LCJONSI6eyJZayI6WyIxIiwiMiJdLCJGbyI6WyIxIiwiMiJdLCJaMCI6WyIxIiwi
-MiJdLCJZay5LIjoiMSIsIllrLlYiOiIyIn0sImk1Ijp7ImJRIjpbIjEiXSwiY1giOlsiMSJdLCJjWC5F
-IjoiMSJ9LCJONiI6eyJBbiI6WyIxIl19LCJWUiI6eyJ3TCI6W10sInZYIjpbXX0sIkVLIjp7ImliIjpb
-XSwiT2QiOltdfSwiS1ciOnsiY1giOlsiaWIiXSwiY1guRSI6ImliIn0sIlBiIjp7IkFuIjpbImliIl19
-LCJ0USI6eyJPZCI6W119LCJ1biI6eyJjWCI6WyJPZCJdLCJjWC5FIjoiT2QifSwiU2QiOnsiQW4iOlsi
-T2QiXX0sIkVUIjp7IkFTIjpbXX0sIkxaIjp7IlhqIjpbIjEiXSwiRVQiOltdLCJBUyI6W119LCJEZyI6
-eyJsRCI6WyJDUCJdLCJYaiI6WyJDUCJdLCJ6TSI6WyJDUCJdLCJFVCI6W10sImJRIjpbIkNQIl0sIkFT
-IjpbXSwiY1giOlsiQ1AiXSwiU1UiOlsiQ1AiXSwibEQuRSI6IkNQIn0sIlBnIjp7ImxEIjpbIklmIl0s
-IlhqIjpbIklmIl0sInpNIjpbIklmIl0sIkVUIjpbXSwiYlEiOlsiSWYiXSwiQVMiOltdLCJjWCI6WyJJ
-ZiJdLCJTVSI6WyJJZiJdfSwieGoiOnsibEQiOlsiSWYiXSwiWGoiOlsiSWYiXSwiek0iOlsiSWYiXSwi
-RVQiOltdLCJiUSI6WyJJZiJdLCJBUyI6W10sImNYIjpbIklmIl0sIlNVIjpbIklmIl0sImxELkUiOiJJ
-ZiJ9LCJkRSI6eyJsRCI6WyJJZiJdLCJYaiI6WyJJZiJdLCJ6TSI6WyJJZiJdLCJFVCI6W10sImJRIjpb
-IklmIl0sIkFTIjpbXSwiY1giOlsiSWYiXSwiU1UiOlsiSWYiXSwibEQuRSI6IklmIn0sIlpBIjp7ImxE
-IjpbIklmIl0sIlhqIjpbIklmIl0sInpNIjpbIklmIl0sIkVUIjpbXSwiYlEiOlsiSWYiXSwiQVMiOltd
-LCJjWCI6WyJJZiJdLCJTVSI6WyJJZiJdLCJsRC5FIjoiSWYifSwiZFQiOnsibEQiOlsiSWYiXSwiWGoi
+QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBRkZGRkZGRkZGRkZGRkZGRkdHR0dHR0dHR0dHR0dHR0dISEhI
+SEhISEhISEhISEhISEhISEhISEhISEhJSEhISkVFQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJC
+S0NDQ0NDQ0NDQ0NDQ0RDTE9OTk5NRUVFRUVFRUVFRUUiLHMpJjMxCmg9aTw9MzI/cyY2MTY5ND4+PnE6
+KHMmNjN8aDw8Nik+Pj4wCmk9Qy54Qi5XKCIgXHgwMDA6WEVDQ0NDQ046bERiIFx4MDAwOlhFQ0NDQ0NO
+dmxEYiBceDAwMDpYRUNDQ0NDTjpsRGIgQUFBQUFceDAwXHgwMFx4MDBceDAwXHgwMEFBQUFBMDAwMDBB
+QUFBQTo6Ojo6QUFBQUFHRzAwMEFBQUFBMDBLS0tBQUFBQUc6Ojo6QUFBQUE6SUlJSUFBQUFBMDAwXHg4
+MDBBQUFBQVx4MDBceDAwXHgwMFx4MDAgQUFBQUEiLGkrcSkKaWYoaT09PTApe2cuYSs9SC5MdyhoKQpp
+ZihmPT09YylicmVhayAkbGFiZWwwJDAKYnJlYWt9ZWxzZSBpZigoaSYxKSE9PTApe2lmKHIpc3dpdGNo
+KGkpe2Nhc2UgNjk6Y2FzZSA2NzpnLmErPUguTHcoaikKYnJlYWsKY2FzZSA2NTpnLmErPUguTHcoaik7
+LS1mCmJyZWFrCmRlZmF1bHQ6cD1nLmErPUguTHcoaikKZy5hPXArSC5MdyhqKQpicmVha31lbHNle2su
+Yj1pCmsuYz1mLTEKcmV0dXJuIiJ9aT0wfWlmKGY9PT1jKWJyZWFrICRsYWJlbDAkMApvPWYrMQppZihm
+PDB8fGY+PWUpcmV0dXJuIEguT0goYSxmKQpzPWFbZl19bz1mKzEKaWYoZjwwfHxmPj1lKXJldHVybiBI
+Lk9IKGEsZikKcz1hW2ZdCmlmKHM8MTI4KXt3aGlsZSghMCl7aWYoIShvPGMpKXtuPWMKYnJlYWt9bT1v
+KzEKaWYobzwwfHxvPj1lKXJldHVybiBILk9IKGEsbykKcz1hW29dCmlmKHM+PTEyOCl7bj1tLTEKbz1t
+CmJyZWFrfW89bX1pZihuLWY8MjApZm9yKGw9ZjtsPG47KytsKXtpZihsPj1lKXJldHVybiBILk9IKGEs
+bCkKZy5hKz1ILkx3KGFbbF0pfWVsc2UgZy5hKz1QLkhNKGEsZixuKQppZihuPT09YylicmVhayAkbGFi
+ZWwwJDAKZj1vfWVsc2UgZj1vfWlmKGQmJmk+MzIpaWYocilnLmErPUguTHcoaikKZWxzZXtrLmI9NzcK
+ay5jPWMKcmV0dXJuIiJ9ay5iPWkKay5jPWgKZT1nLmEKcmV0dXJuIGUuY2hhckNvZGVBdCgwKT09MD9l
+OmV9fQpQLldGLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxCnQuZm8uYShhKQpz
+PXRoaXMuYgpyPXRoaXMuYQpzLmErPXIuYQpxPXMuYSs9SC5FaihhLmEpCnMuYT1xKyI6ICIKcy5hKz1Q
+LnAoYikKci5hPSIsICJ9LAokUzo0Mn0KUC5pUC5wcm90b3R5cGU9ewpETjpmdW5jdGlvbihhLGIpe2lm
+KGI9PW51bGwpcmV0dXJuITEKcmV0dXJuIGIgaW5zdGFuY2VvZiBQLmlQJiZ0aGlzLmE9PT1iLmEmJiEw
+fSwKZ2lPOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuYQpyZXR1cm4oc15DLmpuLndHKHMsMzApKSYxMDcz
+NzQxODIzfSwKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLHI9UC5HcShILnRKKHMpKSxxPVAuaDAoSC5O
+UyhzKSkscD1QLmgwKEguakEocykpLG89UC5oMChILklYKHMpKSxuPVAuaDAoSC5jaChzKSksbT1QLmgw
+KEguSmQocykpLGw9UC5WeChILm8xKHMpKSxrPXIrIi0iK3ErIi0iK3ArIiAiK28rIjoiK24rIjoiK20r
+Ii4iK2wKcmV0dXJuIGt9fQpQLlhTLnByb3RvdHlwZT17CmdJSTpmdW5jdGlvbigpe3JldHVybiBILnRz
+KHRoaXMuJHRocm93bkpzRXJyb3IpfX0KUC5DNi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBz
+PXRoaXMuYQppZihzIT1udWxsKXJldHVybiJBc3NlcnRpb24gZmFpbGVkOiAiK1AucChzKQpyZXR1cm4i
+QXNzZXJ0aW9uIGZhaWxlZCJ9fQpQLkV6LnByb3RvdHlwZT17fQpQLkYucHJvdG90eXBlPXsKdzpmdW5j
+dGlvbihhKXtyZXR1cm4iVGhyb3cgb2YgbnVsbC4ifX0KUC51LnByb3RvdHlwZT17CmdaOmZ1bmN0aW9u
+KCl7cmV0dXJuIkludmFsaWQgYXJndW1lbnQiKyghdGhpcy5hPyIocykiOiIiKX0sCmd1OmZ1bmN0aW9u
+KCl7cmV0dXJuIiJ9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9cS5jLG89cD09bnVsbD8i
+IjoiICgiK3ArIikiLG49cS5kLG09bj09bnVsbD8iIjoiOiAiK0guRWoobiksbD1xLmdaKCkrbyttCmlm
+KCFxLmEpcmV0dXJuIGwKcz1xLmd1KCkKcj1QLnAocS5iKQpyZXR1cm4gbCtzKyI6ICIrcn19ClAuYkou
+cHJvdG90eXBlPXsKZ1o6ZnVuY3Rpb24oKXtyZXR1cm4iUmFuZ2VFcnJvciJ9LApndTpmdW5jdGlvbigp
+e3ZhciBzLHI9dGhpcy5lLHE9dGhpcy5mCmlmKHI9PW51bGwpcz1xIT1udWxsPyI6IE5vdCBsZXNzIHRo
+YW4gb3IgZXF1YWwgdG8gIitILkVqKHEpOiIiCmVsc2UgaWYocT09bnVsbClzPSI6IE5vdCBncmVhdGVy
+IHRoYW4gb3IgZXF1YWwgdG8gIitILkVqKHIpCmVsc2UgaWYocT5yKXM9IjogTm90IGluIGluY2x1c2l2
+ZSByYW5nZSAiK0guRWoocikrIi4uIitILkVqKHEpCmVsc2Ugcz1xPHI/IjogVmFsaWQgdmFsdWUgcmFu
+Z2UgaXMgZW1wdHkiOiI6IE9ubHkgdmFsaWQgdmFsdWUgaXMgIitILkVqKHIpCnJldHVybiBzfX0KUC5l
+WS5wcm90b3R5cGU9ewpnWjpmdW5jdGlvbigpe3JldHVybiJSYW5nZUVycm9yIn0sCmd1OmZ1bmN0aW9u
+KCl7dmFyIHMscj1ILnVQKHRoaXMuYikKaWYodHlwZW9mIHIhPT0ibnVtYmVyIilyZXR1cm4gci5KKCkK
+aWYocjwwKXJldHVybiI6IGluZGV4IG11c3Qgbm90IGJlIG5lZ2F0aXZlIgpzPXRoaXMuZgppZihzPT09
+MClyZXR1cm4iOiBubyBpbmRpY2VzIGFyZSB2YWxpZCIKcmV0dXJuIjogaW5kZXggc2hvdWxkIGJlIGxl
+c3MgdGhhbiAiK0guRWoocyl9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5mfX0KUC5tcC5wcm90
+b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8sbixtLGwsaz10aGlzLGo9e30saT1uZXcg
+UC5SbigiIikKai5hPSIiCnM9ay5jCmZvcihyPXMubGVuZ3RoLHE9MCxwPSIiLG89IiI7cTxyOysrcSxv
+PSIsICIpe249c1txXQppLmE9cCtvCnA9aS5hKz1QLnAobikKai5hPSIsICJ9ay5kLksoMCxuZXcgUC5X
+RihqLGkpKQptPVAucChrLmEpCmw9aS53KDApCnI9Ik5vU3VjaE1ldGhvZEVycm9yOiBtZXRob2Qgbm90
+IGZvdW5kOiAnIitILkVqKGsuYi5hKSsiJ1xuUmVjZWl2ZXI6ICIrbSsiXG5Bcmd1bWVudHM6IFsiK2wr
+Il0iCnJldHVybiByfX0KUC51Yi5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJVbnN1cHBv
+cnRlZCBvcGVyYXRpb246ICIrdGhpcy5hfX0KUC5kcy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3Zh
+ciBzPXRoaXMuYQpyZXR1cm4gcyE9bnVsbD8iVW5pbXBsZW1lbnRlZEVycm9yOiAiK3M6IlVuaW1wbGVt
+ZW50ZWRFcnJvciJ9fQpQLmxqLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkJhZCBzdGF0
+ZTogIit0aGlzLmF9fQpQLlVWLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5hCmlm
+KHM9PW51bGwpcmV0dXJuIkNvbmN1cnJlbnQgbW9kaWZpY2F0aW9uIGR1cmluZyBpdGVyYXRpb24uIgpy
+ZXR1cm4iQ29uY3VycmVudCBtb2RpZmljYXRpb24gZHVyaW5nIGl0ZXJhdGlvbjogIitQLnAocykrIi4i
+fX0KUC5rNS5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJPdXQgb2YgTWVtb3J5In0sCmdJ
+STpmdW5jdGlvbigpe3JldHVybiBudWxsfSwKJGlYUzoxfQpQLktZLnByb3RvdHlwZT17Cnc6ZnVuY3Rp
+b24oYSl7cmV0dXJuIlN0YWNrIE92ZXJmbG93In0sCmdJSTpmdW5jdGlvbigpe3JldHVybiBudWxsfSwK
+JGlYUzoxfQpQLmMucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEKcmV0dXJuIHM9
+PW51bGw/IlJlYWRpbmcgc3RhdGljIHZhcmlhYmxlIGR1cmluZyBpdHMgaW5pdGlhbGl6YXRpb24iOiJS
+ZWFkaW5nIHN0YXRpYyB2YXJpYWJsZSAnIitzKyInIGR1cmluZyBpdHMgaW5pdGlhbGl6YXRpb24ifX0K
+UC5DRC5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEpe3JldHVybiJFeGNlcHRpb246ICIrdGhpcy5hfSwK
+JGlSejoxfQpQLmFFLnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxr
+LGosaSxoLGc9dGhpcy5hLGY9ZyE9bnVsbCYmIiIhPT1nPyJGb3JtYXRFeGNlcHRpb246ICIrSC5Faihn
+KToiRm9ybWF0RXhjZXB0aW9uIixlPXRoaXMuYyxkPXRoaXMuYgppZih0eXBlb2YgZD09InN0cmluZyIp
+e2lmKGUhPW51bGwpcz1lPDB8fGU+ZC5sZW5ndGgKZWxzZSBzPSExCmlmKHMpZT1udWxsCmlmKGU9PW51
+bGwpe2lmKGQubGVuZ3RoPjc4KWQ9Qy54Qi5OaihkLDAsNzUpKyIuLi4iCnJldHVybiBmKyJcbiIrZH1m
+b3Iocj0xLHE9MCxwPSExLG89MDtvPGU7KytvKXtuPUMueEIuVyhkLG8pCmlmKG49PT0xMCl7aWYocSE9
+PW98fCFwKSsrcgpxPW8rMQpwPSExfWVsc2UgaWYobj09PTEzKXsrK3IKcT1vKzEKcD0hMH19Zj1yPjE/
+ZisoIiAoYXQgbGluZSAiK3IrIiwgY2hhcmFjdGVyICIrKGUtcSsxKSsiKVxuIik6ZisoIiAoYXQgY2hh
+cmFjdGVyICIrKGUrMSkrIilcbiIpCm09ZC5sZW5ndGgKZm9yKG89ZTtvPG07KytvKXtuPUMueEIuTzIo
+ZCxvKQppZihuPT09MTB8fG49PT0xMyl7bT1vCmJyZWFrfX1pZihtLXE+NzgpaWYoZS1xPDc1KXtsPXEr
+NzUKaz1xCmo9IiIKaT0iLi4uIn1lbHNle2lmKG0tZTw3NSl7az1tLTc1Cmw9bQppPSIifWVsc2V7az1l
+LTM2Cmw9ZSszNgppPSIuLi4ifWo9Ii4uLiJ9ZWxzZXtsPW0Kaz1xCmo9IiIKaT0iIn1oPUMueEIuTmoo
+ZCxrLGwpCnJldHVybiBmK2oraCtpKyJcbiIrQy54Qi5UKCIgIixlLWsrai5sZW5ndGgpKyJeXG4ifWVs
+c2UgcmV0dXJuIGUhPW51bGw/ZisoIiAoYXQgb2Zmc2V0ICIrSC5FaihlKSsiKSIpOmZ9LAokaVJ6OjF9
+ClAuY1gucHJvdG90eXBlPXsKZHI6ZnVuY3Rpb24oYSxiKXtyZXR1cm4gSC5HSih0aGlzLEguTGgodGhp
+cykuQygiY1guRSIpLGIpfSwKRTI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPUguTGgodGhpcykKcmV0dXJu
+IEguSzEodGhpcyxzLktxKGMpLkMoIjEoY1guRSkiKS5hKGIpLHMuQygiY1guRSIpLGMpfSwKZXY6ZnVu
+Y3Rpb24oYSxiKXt2YXIgcz1ILkxoKHRoaXMpCnJldHVybiBuZXcgSC5VNSh0aGlzLHMuQygiYTIoY1gu
+RSkiKS5hKGIpLHMuQygiVTU8Y1guRT4iKSl9LAp0dDpmdW5jdGlvbihhLGIpe3JldHVybiBQLlkxKHRo
+aXMsYixILkxoKHRoaXMpLkMoImNYLkUiKSl9LApicjpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy50dChh
+LCEwKX0sCmdBOmZ1bmN0aW9uKGEpe3ZhciBzLHI9dGhpcy5nbSh0aGlzKQpmb3Iocz0wO3IuRigpOykr
+K3MKcmV0dXJuIHN9LApnbDA6ZnVuY3Rpb24oYSl7cmV0dXJuIXRoaXMuZ20odGhpcykuRigpfSwKZ29y
+OmZ1bmN0aW9uKGEpe3JldHVybiF0aGlzLmdsMCh0aGlzKX0sCmVSOmZ1bmN0aW9uKGEsYil7cmV0dXJu
+IEguYksodGhpcyxiLEguTGgodGhpcykuQygiY1guRSIpKX0sCmdyODpmdW5jdGlvbihhKXt2YXIgcyxy
+PXRoaXMuZ20odGhpcykKaWYoIXIuRigpKXRocm93IEguYihILldwKCkpCnM9ci5nbCgpCmlmKHIuRigp
+KXRocm93IEguYihILkFtKCkpCnJldHVybiBzfSwKRTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscQpQLmsx
+KGIsImluZGV4IikKZm9yKHM9dGhpcy5nbSh0aGlzKSxyPTA7cy5GKCk7KXtxPXMuZ2woKQppZihiPT09
+cilyZXR1cm4gcTsrK3J9dGhyb3cgSC5iKFAuQ2YoYix0aGlzLCJpbmRleCIsbnVsbCxyKSl9LAp3OmZ1
+bmN0aW9uKGEpe3JldHVybiBQLkVQKHRoaXMsIigiLCIpIil9fQpQLkFuLnByb3RvdHlwZT17fQpQLk4z
+LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIk1hcEVudHJ5KCIrSC5FaihKLmoodGhpcy5h
+KSkrIjogIitILkVqKEouaih0aGlzLmIpKSsiKSJ9fQpQLmM4LnByb3RvdHlwZT17CmdpTzpmdW5jdGlv
+bihhKXtyZXR1cm4gUC5NaC5wcm90b3R5cGUuZ2lPLmNhbGwoQy5qTix0aGlzKX0sCnc6ZnVuY3Rpb24o
+YSl7cmV0dXJuIm51bGwifX0KUC5NaC5wcm90b3R5cGU9e2NvbnN0cnVjdG9yOlAuTWgsJGlNaDoxLApE
+TjpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlzPT09Yn0sCmdpTzpmdW5jdGlvbihhKXtyZXR1cm4gSC5l
+USh0aGlzKX0sCnc6ZnVuY3Rpb24oYSl7cmV0dXJuIkluc3RhbmNlIG9mICciK0guRWooSC5NKHRoaXMp
+KSsiJyJ9LAplNzpmdW5jdGlvbihhLGIpe3Quby5hKGIpCnRocm93IEguYihQLmxyKHRoaXMsYi5nV2Eo
+KSxiLmduZCgpLGIuZ1ZtKCkpKX0sCnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMudyh0aGlz
+KX19ClAuWmQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4iIn0sCiRpR3o6MX0KUC5Sbi5w
+cm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnc6ZnVuY3Rpb24o
+YSl7dmFyIHM9dGhpcy5hCnJldHVybiBzLmNoYXJDb2RlQXQoMCk9PTA/czpzfSwKJGlCTDoxfQpQLm4x
+LnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxLHAKdC5KLmEoYSkKSC5oKGIpCnM9
+Si5yWShiKS5PWShiLCI9IikKaWYocz09PS0xKXtpZihiIT09IiIpYS5ZNSgwLFAua3UoYiwwLGIubGVu
+Z3RoLHRoaXMuYSwhMCksIiIpfWVsc2UgaWYocyE9PTApe3I9Qy54Qi5OaihiLDAscykKcT1DLnhCLnlu
+KGIscysxKQpwPXRoaXMuYQphLlk1KDAsUC5rdShyLDAsci5sZW5ndGgscCwhMCksUC5rdShxLDAscS5s
+ZW5ndGgscCwhMCkpfXJldHVybiBhfSwKJFM6NDR9ClAuY1MucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24o
+YSxiKXt0aHJvdyBILmIoUC5ycigiSWxsZWdhbCBJUHY0IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwK
+JFM6MjF9ClAuVkMucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aHJvdyBILmIoUC5ycigiSWxs
+ZWdhbCBJUHY2IGFkZHJlc3MsICIrYSx0aGlzLmEsYikpfSwKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRo
+aXMuJDIoYSxudWxsKX0sCiRTOjQ5fQpQLkpULnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFy
+IHMKaWYoYi1hPjQpdGhpcy5hLiQyKCJhbiBJUHY2IHBhcnQgY2FuIG9ubHkgY29udGFpbiBhIG1heGlt
+dW0gb2YgNCBoZXggZGlnaXRzIixhKQpzPVAuUUEoQy54Qi5Oaih0aGlzLmIsYSxiKSwxNikKaWYoczww
+fHxzPjY1NTM1KXRoaXMuYS4kMigiZWFjaCBwYXJ0IG11c3QgYmUgaW4gdGhlIHJhbmdlIG9mIGAweDAu
+LjB4RkZGRmAiLGEpCnJldHVybiBzfSwKJFM6NTF9ClAuRG4ucHJvdG90eXBlPXsKZ25EOmZ1bmN0aW9u
+KCl7dmFyIHMscixxLHAsbz10aGlzCmlmKCFvLnkpe3M9by5hCnI9cy5sZW5ndGghPT0wP3MrIjoiOiIi
+CnE9by5jCnA9cT09bnVsbAppZighcHx8cz09PSJmaWxlIil7cz1yKyIvLyIKcj1vLmIKaWYoci5sZW5n
+dGghPT0wKXM9cytyKyJAIgppZighcClzKz1xCnI9by5kCmlmKHIhPW51bGwpcz1zKyI6IitILkVqKHIp
+fWVsc2Ugcz1yCnMrPW8uZQpyPW8uZgppZihyIT1udWxsKXM9cysiPyIrcgpyPW8ucgppZihyIT1udWxs
+KXM9cysiIyIrcgppZihvLnkpdGhyb3cgSC5iKEguR1EoIl90ZXh0IikpCm8ueD1zLmNoYXJDb2RlQXQo
+MCk9PTA/czpzCm8ueT0hMH1yZXR1cm4gby54fSwKZ0ZqOmZ1bmN0aW9uKCl7dmFyIHMscixxPXRoaXMK
+aWYoIXEuUSl7cz1xLmUKaWYocy5sZW5ndGghPT0wJiZDLnhCLlcocywwKT09PTQ3KXM9Qy54Qi55bihz
+LDEpCnI9cy5sZW5ndGg9PT0wP0MueEQ6UC5BRihuZXcgSC5sSihILlZNKHMuc3BsaXQoIi8iKSx0LnMp
+LHQuZE8uYShQLlBIKCkpLHQuZG8pLHQuTikKaWYocS5RKXRocm93IEguYihILkdRKCJwYXRoU2VnbWVu
+dHMiKSkKcS5zS3AocikKcS5RPSEwfXJldHVybiBxLnp9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscj10
+aGlzCmlmKCFyLmN4KXtzPUouaGYoci5nbkQoKSkKaWYoci5jeCl0aHJvdyBILmIoSC5HUSgiaGFzaENv
+ZGUiKSkKci5jaD1zCnIuY3g9ITB9cmV0dXJuIHIuY2h9LApnaFk6ZnVuY3Rpb24oKXt2YXIgcyxyPXRo
+aXMKaWYoIXIuZGIpe3M9UC5XWChyLmd0UCgpKQppZihyLmRiKXRocm93IEguYihILkdRKCJxdWVyeVBh
+cmFtZXRlcnMiKSkKci5zTk0obmV3IFAuR2oocyx0LmR3KSkKci5kYj0hMH1yZXR1cm4gci5jeX0sCmdr
+dTpmdW5jdGlvbigpe3JldHVybiB0aGlzLmJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCmlm
+KHM9PW51bGwpcmV0dXJuIiIKaWYoQy54Qi5uQyhzLCJbIikpcmV0dXJuIEMueEIuTmoocywxLHMubGVu
+Z3RoLTEpCnJldHVybiBzfSwKZ3RwOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZApyZXR1cm4gcz09bnVs
+bD9QLndLKHRoaXMuYSk6c30sCmd0UDpmdW5jdGlvbigpe3ZhciBzPXRoaXMuZgpyZXR1cm4gcz09bnVs
+bD8iIjpzfSwKZ0thOmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5yCnJldHVybiBzPT1udWxsPyIiOnN9LApu
+bTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxqPXRoaXMKdC5jOS5hKGIpCnM9ai5h
+CnI9cz09PSJmaWxlIgpxPWouYgpwPWouZApvPWouYwppZighKG8hPW51bGwpKW89cS5sZW5ndGghPT0w
+fHxwIT1udWxsfHxyPyIiOm51bGwKbj1qLmUKaWYoIXIpbT1vIT1udWxsJiZuLmxlbmd0aCE9PTAKZWxz
+ZSBtPSEwCmlmKG0mJiFDLnhCLm5DKG4sIi8iKSluPSIvIituCmw9bgprPVAubGUobnVsbCwwLDAsYikK
+cmV0dXJuIG5ldyBQLkRuKHMscSxvLHAsbCxrLGoucil9LApKaDpmdW5jdGlvbihhLGIpe3ZhciBzLHIs
+cSxwLG8sbgpmb3Iocz0wLHI9MDtDLnhCLlFpKGIsIi4uLyIscik7KXtyKz0zOysrc31xPUMueEIuY24o
+YSwiLyIpCndoaWxlKCEwKXtpZighKHE+MCYmcz4wKSlicmVhawpwPUMueEIuUGsoYSwiLyIscS0xKQpp
+ZihwPDApYnJlYWsKbz1xLXAKbj1vIT09MgppZighbnx8bz09PTMpaWYoQy54Qi5PMihhLHArMSk9PT00
+NiluPSFufHxDLnhCLk8yKGEscCsyKT09PTQ2CmVsc2Ugbj0hMQplbHNlIG49ITEKaWYobilicmVhazst
+LXMKcT1wfXJldHVybiBDLnhCLmk3KGEscSsxLG51bGwsQy54Qi55bihiLHItMypzKSl9LApaSTpmdW5j
+dGlvbihhKXtyZXR1cm4gdGhpcy5tUyhQLmhLKGEpKX0sCm1TOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxw
+LG8sbixtLGwsayxqPXRoaXMsaT1udWxsCmlmKGEuZ0ZpKCkubGVuZ3RoIT09MCl7cz1hLmdGaSgpCmlm
+KGEuZ2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9YS5neEEoKT9hLmd0cChhKTppfWVsc2V7cD1p
+CnE9cApyPSIifW89UC54ZShhLmdJaShhKSkKbj1hLmdRRCgpP2EuZ3RQKCk6aX1lbHNle3M9ai5hCmlm
+KGEuZ2NqKCkpe3I9YS5na3UoKQpxPWEuZ0pmKGEpCnA9UC53QihhLmd4QSgpP2EuZ3RwKGEpOmkscykK
+bz1QLnhlKGEuZ0lpKGEpKQpuPWEuZ1FEKCk/YS5ndFAoKTppfWVsc2V7cj1qLmIKcT1qLmMKcD1qLmQK
+aWYoYS5nSWkoYSk9PT0iIil7bz1qLmUKbj1hLmdRRCgpP2EuZ3RQKCk6ai5mfWVsc2V7aWYoYS5ndFQo
+KSlvPVAueGUoYS5nSWkoYSkpCmVsc2V7bT1qLmUKaWYobS5sZW5ndGg9PT0wKWlmKHE9PW51bGwpbz1z
+Lmxlbmd0aD09PTA/YS5nSWkoYSk6UC54ZShhLmdJaShhKSkKZWxzZSBvPVAueGUoIi8iK2EuZ0lpKGEp
+KQplbHNle2w9ai5KaChtLGEuZ0lpKGEpKQprPXMubGVuZ3RoPT09MAppZigha3x8cSE9bnVsbHx8Qy54
+Qi5uQyhtLCIvIikpbz1QLnhlKGwpCmVsc2Ugbz1QLndGKGwsIWt8fHEhPW51bGwpfX1uPWEuZ1FEKCk/
+YS5ndFAoKTppfX19cmV0dXJuIG5ldyBQLkRuKHMscixxLHAsbyxuLGEuZ1o4KCk/YS5nS2EoKTppKX0s
+CmdjajpmdW5jdGlvbigpe3JldHVybiB0aGlzLmMhPW51bGx9LApneEE6ZnVuY3Rpb24oKXtyZXR1cm4g
+dGhpcy5kIT1udWxsfSwKZ1FEOmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMuZiE9bnVsbH0sCmdaODpmdW5j
+dGlvbigpe3JldHVybiB0aGlzLnIhPW51bGx9LApndFQ6ZnVuY3Rpb24oKXtyZXR1cm4gQy54Qi5uQyh0
+aGlzLmUsIi8iKX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9ci5hCmlmKHEhPT0iIiYmcSE9
+PSJmaWxlIil0aHJvdyBILmIoUC5MNCgiQ2Fubm90IGV4dHJhY3QgYSBmaWxlIHBhdGggZnJvbSBhICIr
+cSsiIFVSSSIpKQppZihyLmd0UCgpIT09IiIpdGhyb3cgSC5iKFAuTDQodS5pKSkKaWYoci5nS2EoKSE9
+PSIiKXRocm93IEguYihQLkw0KHUubCkpCnE9JC53USgpCmlmKEgub1QocSkpcT1QLm1uKHIpCmVsc2V7
+aWYoci5jIT1udWxsJiZyLmdKZihyKSE9PSIiKUgudihQLkw0KHUuaikpCnM9ci5nRmooKQpQLmtFKHMs
+ITEpCnE9UC52ZyhDLnhCLm5DKHIuZSwiLyIpPyIvIjoiIixzLCIvIikKcT1xLmNoYXJDb2RlQXQoMCk9
+PTA/cTpxfXJldHVybiBxfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nbkQoKX0sCkROOmZ1bmN0
+aW9uKGEsYil7dmFyIHM9dGhpcwppZihiPT1udWxsKXJldHVybiExCmlmKHM9PT1iKXJldHVybiEwCnJl
+dHVybiB0LmRELmIoYikmJnMuYT09PWIuZ0ZpKCkmJnMuYyE9bnVsbD09PWIuZ2NqKCkmJnMuYj09PWIu
+Z2t1KCkmJnMuZ0pmKHMpPT09Yi5nSmYoYikmJnMuZ3RwKHMpPT09Yi5ndHAoYikmJnMuZT09PWIuZ0lp
+KGIpJiZzLmYhPW51bGw9PT1iLmdRRCgpJiZzLmd0UCgpPT09Yi5ndFAoKSYmcy5yIT1udWxsPT09Yi5n
+WjgoKSYmcy5nS2EoKT09PWIuZ0thKCl9LApzS3A6ZnVuY3Rpb24oYSl7dGhpcy56PXQuYmsuYShhKX0s
+CnNOTTpmdW5jdGlvbihhKXt0aGlzLmN5PXQuY1ouYShhKX0sCiRpaUQ6MSwKZ0ZpOmZ1bmN0aW9uKCl7
+cmV0dXJuIHRoaXMuYX0sCmdJaTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5lfX0KUC5SWi5wcm90b3R5
+cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gUC5lUChDLlpKLEguaChhKSxDLnhNLCExKX0sCiRTOjV9
+ClAuTUUucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcz10aGlzLmIscj10aGlzLmEKcy5h
+Kz1yLmEKci5hPSImIgpyPXMuYSs9SC5FaihQLmVQKEMuRjMsYSxDLnhNLCEwKSkKaWYoYiE9bnVsbCYm
+Yi5sZW5ndGghPT0wKXtzLmE9cisiPSIKcy5hKz1ILkVqKFAuZVAoQy5GMyxiLEMueE0sITApKX19LAok
+UzoyMn0KUC55NS5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKSC5oKGEpCmlmKGI9
+PW51bGx8fHR5cGVvZiBiPT0ic3RyaW5nIil0aGlzLmEuJDIoYSxILmsoYikpCmVsc2UgZm9yKHM9Si5J
+VCh0LnUuYShiKSkscj10aGlzLmE7cy5GKCk7KXIuJDIoYSxILmgocy5nbCgpKSl9LAokUzoxMn0KUC5Q
+RS5wcm90b3R5cGU9ewpnbFI6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvPXRoaXMsbj1udWxsLG09by5j
+CmlmKG09PW51bGwpe209by5iCmlmKDA+PW0ubGVuZ3RoKXJldHVybiBILk9IKG0sMCkKcz1vLmEKbT1t
+WzBdKzEKcj1DLnhCLlhVKHMsIj8iLG0pCnE9cy5sZW5ndGgKaWYocj49MCl7cD1QLlBJKHMscisxLHEs
+Qy5WQywhMSkKcT1yfWVsc2UgcD1uCm09by5jPW5ldyBQLnFlKCJkYXRhIiwiIixuLG4sUC5QSShzLG0s
+cSxDLldkLCExKSxwLG4pfXJldHVybiBtfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyPXRoaXMuYgppZigw
+Pj1yLmxlbmd0aClyZXR1cm4gSC5PSChyLDApCnM9dGhpcy5hCnJldHVybiByWzBdPT09LTE/ImRhdGE6
+IitzOnN9fQpQLnlJLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5hCmlmKGE+
+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsYSkKcz1zW2FdCkMuTkEuZHUocywwLDk2LGIpCnJldHVybiBz
+fSwKJFM6MjN9ClAuYzYucHJvdG90eXBlPXsKJDM6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzLHIscQpmb3Io
+cz1iLmxlbmd0aCxyPTA7cjxzOysrcil7cT1DLnhCLlcoYixyKV45NgppZihxPj05NilyZXR1cm4gSC5P
+SChhLHEpCmFbcV09Y319LAokUzoxM30KUC5xZC5wcm90b3R5cGU9ewokMzpmdW5jdGlvbihhLGIsYyl7
+dmFyIHMscixxCmZvcihzPUMueEIuVyhiLDApLHI9Qy54Qi5XKGIsMSk7czw9cjsrK3Mpe3E9KHNeOTYp
+Pj4+MAppZihxPj05NilyZXR1cm4gSC5PSChhLHEpCmFbcV09Y319LAokUzoxM30KUC5VZi5wcm90b3R5
+cGU9ewpnY2o6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5jPjB9LApneEE6ZnVuY3Rpb24oKXtyZXR1cm4g
+dGhpcy5jPjAmJnRoaXMuZCsxPHRoaXMuZX0sCmdRRDpmdW5jdGlvbigpe3JldHVybiB0aGlzLmY8dGhp
+cy5yfSwKZ1o4OmZ1bmN0aW9uKCl7cmV0dXJuIHRoaXMucjx0aGlzLmEubGVuZ3RofSwKZ053OmZ1bmN0
+aW9uKCl7cmV0dXJuIHRoaXMuYj09PTQmJkMueEIubkModGhpcy5hLCJmaWxlIil9LApnV1o6ZnVuY3Rp
+b24oKXtyZXR1cm4gdGhpcy5iPT09NCYmQy54Qi5uQyh0aGlzLmEsImh0dHAiKX0sCmdSZTpmdW5jdGlv
+bigpe3JldHVybiB0aGlzLmI9PT01JiZDLnhCLm5DKHRoaXMuYSwiaHR0cHMiKX0sCmd0VDpmdW5jdGlv
+bigpe3JldHVybiBDLnhCLlFpKHRoaXMuYSwiLyIsdGhpcy5lKX0sCmdGaTpmdW5jdGlvbigpe3ZhciBz
+PXRoaXMueApyZXR1cm4gcz09bnVsbD90aGlzLng9dGhpcy5VMigpOnN9LApVMjpmdW5jdGlvbigpe3Zh
+ciBzPXRoaXMscj1zLmIKaWYocjw9MClyZXR1cm4iIgppZihzLmdXWigpKXJldHVybiJodHRwIgppZihz
+LmdSZSgpKXJldHVybiJodHRwcyIKaWYocy5nTncoKSlyZXR1cm4iZmlsZSIKaWYocj09PTcmJkMueEIu
+bkMocy5hLCJwYWNrYWdlIikpcmV0dXJuInBhY2thZ2UiCnJldHVybiBDLnhCLk5qKHMuYSwwLHIpfSwK
+Z2t1OmZ1bmN0aW9uKCl7dmFyIHM9dGhpcy5jLHI9dGhpcy5iKzMKcmV0dXJuIHM+cj9DLnhCLk5qKHRo
+aXMuYSxyLHMtMSk6IiJ9LApnSmY6ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy5jCnJldHVybiBzPjA/Qy54
+Qi5Oaih0aGlzLmEscyx0aGlzLmQpOiIifSwKZ3RwOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMKaWYocy5n
+eEEoKSlyZXR1cm4gUC5RQShDLnhCLk5qKHMuYSxzLmQrMSxzLmUpLG51bGwpCmlmKHMuZ1daKCkpcmV0
+dXJuIDgwCmlmKHMuZ1JlKCkpcmV0dXJuIDQ0MwpyZXR1cm4gMH0sCmdJaTpmdW5jdGlvbihhKXtyZXR1
+cm4gQy54Qi5Oaih0aGlzLmEsdGhpcy5lLHRoaXMuZil9LApndFA6ZnVuY3Rpb24oKXt2YXIgcz10aGlz
+LmYscj10aGlzLnIKcmV0dXJuIHM8cj9DLnhCLk5qKHRoaXMuYSxzKzEscik6IiJ9LApnS2E6ZnVuY3Rp
+b24oKXt2YXIgcz10aGlzLnIscj10aGlzLmEKcmV0dXJuIHM8ci5sZW5ndGg/Qy54Qi55bihyLHMrMSk6
+IiJ9LApnRmo6ZnVuY3Rpb24oKXt2YXIgcyxyLHE9dGhpcy5lLHA9dGhpcy5mLG89dGhpcy5hCmlmKEMu
+eEIuUWkobywiLyIscSkpKytxCmlmKHE9PT1wKXJldHVybiBDLnhECnM9SC5WTShbXSx0LnMpCmZvcihy
+PXE7cjxwOysrcilpZihDLnhCLk8yKG8scik9PT00Nyl7Qy5ObS5pKHMsQy54Qi5OaihvLHEscikpCnE9
+cisxfUMuTm0uaShzLEMueEIuTmoobyxxLHApKQpyZXR1cm4gUC5BRihzLHQuTil9LApnaFk6ZnVuY3Rp
+b24oKXtpZih0aGlzLmY+PXRoaXMucilyZXR1cm4gQy5DTQpyZXR1cm4gbmV3IFAuR2ooUC5XWCh0aGlz
+Lmd0UCgpKSx0LmR3KX0sCmtYOmZ1bmN0aW9uKGEpe3ZhciBzPXRoaXMuZCsxCnJldHVybiBzK2EubGVu
+Z3RoPT09dGhpcy5lJiZDLnhCLlFpKHRoaXMuYSxhLHMpfSwKTjk6ZnVuY3Rpb24oKXt2YXIgcz10aGlz
+LHI9cy5yLHE9cy5hCmlmKHI+PXEubGVuZ3RoKXJldHVybiBzCnJldHVybiBuZXcgUC5VZihDLnhCLk5q
+KHEsMCxyKSxzLmIscy5jLHMuZCxzLmUscy5mLHIscy54KX0sCm5tOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxLHAsbyxuLG0sbCxrLGosaT10aGlzLGg9bnVsbAp0LmM5LmEoYikKcz1pLmdGaSgpCnI9cz09PSJm
+aWxlIgpxPWkuYwpwPXE+MD9DLnhCLk5qKGkuYSxpLmIrMyxxKToiIgpvPWkuZ3hBKCk/aS5ndHAoaSk6
+aApxPWkuYwppZihxPjApbj1DLnhCLk5qKGkuYSxxLGkuZCkKZWxzZSBuPXAubGVuZ3RoIT09MHx8byE9
+bnVsbHx8cj8iIjpoCnE9aS5hCm09Qy54Qi5OaihxLGkuZSxpLmYpCmlmKCFyKWw9biE9bnVsbCYmbS5s
+ZW5ndGghPT0wCmVsc2UgbD0hMAppZihsJiYhQy54Qi5uQyhtLCIvIikpbT0iLyIrbQprPVAubGUoaCww
+LDAsYikKbD1pLnIKaj1sPHEubGVuZ3RoP0MueEIueW4ocSxsKzEpOmgKcmV0dXJuIG5ldyBQLkRuKHMs
+cCxuLG8sbSxrLGopfSwKWkk6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMubVMoUC5oSyhhKSl9LAptUzpm
+dW5jdGlvbihhKXtpZihhIGluc3RhbmNlb2YgUC5VZilyZXR1cm4gdGhpcy51MSh0aGlzLGEpCnJldHVy
+biB0aGlzLnZzKCkubVMoYSl9LAp1MTpmdW5jdGlvbihhLGIpe3ZhciBzLHIscSxwLG8sbixtLGwsayxq
+LGksaCxnPWIuYgppZihnPjApcmV0dXJuIGIKcz1iLmMKaWYocz4wKXtyPWEuYgppZihyPD0wKXJldHVy
+biBiCmlmKGEuZ053KCkpcT1iLmUhPT1iLmYKZWxzZSBpZihhLmdXWigpKXE9IWIua1goIjgwIikKZWxz
+ZSBxPSFhLmdSZSgpfHwhYi5rWCgiNDQzIikKaWYocSl7cD1yKzEKcmV0dXJuIG5ldyBQLlVmKEMueEIu
+TmooYS5hLDAscCkrQy54Qi55bihiLmEsZysxKSxyLHMrcCxiLmQrcCxiLmUrcCxiLmYrcCxiLnIrcCxh
+LngpfWVsc2UgcmV0dXJuIHRoaXMudnMoKS5tUyhiKX1vPWIuZQpnPWIuZgppZihvPT09Zyl7cz1iLnIK
+aWYoZzxzKXtyPWEuZgpwPXItZwpyZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihhLmEsMCxyKStDLnhCLnlu
+KGIuYSxnKSxhLmIsYS5jLGEuZCxhLmUsZytwLHMrcCxhLngpfWc9Yi5hCmlmKHM8Zy5sZW5ndGgpe3I9
+YS5yCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4oZyxzKSxhLmIsYS5jLGEu
+ZCxhLmUsYS5mLHMrKHItcyksYS54KX1yZXR1cm4gYS5OOSgpfXM9Yi5hCmlmKEMueEIuUWkocywiLyIs
+bykpe3I9YS5lCnA9ci1vCnJldHVybiBuZXcgUC5VZihDLnhCLk5qKGEuYSwwLHIpK0MueEIueW4ocyxv
+KSxhLmIsYS5jLGEuZCxyLGcrcCxiLnIrcCxhLngpfW49YS5lCm09YS5mCmlmKG49PT1tJiZhLmM+MCl7
+Zm9yKDtDLnhCLlFpKHMsIi4uLyIsbyk7KW8rPTMKcD1uLW8rMQpyZXR1cm4gbmV3IFAuVWYoQy54Qi5O
+aihhLmEsMCxuKSsiLyIrQy54Qi55bihzLG8pLGEuYixhLmMsYS5kLG4sZytwLGIucitwLGEueCl9bD1h
+LmEKZm9yKGs9bjtDLnhCLlFpKGwsIi4uLyIsayk7KWsrPTMKaj0wCndoaWxlKCEwKXtpPW8rMwppZigh
+KGk8PWcmJkMueEIuUWkocywiLi4vIixvKSkpYnJlYWs7KytqCm89aX1mb3IoaD0iIjttPms7KXstLW0K
+aWYoQy54Qi5PMihsLG0pPT09NDcpe2lmKGo9PT0wKXtoPSIvIgpicmVha30tLWoKaD0iLyJ9fWlmKG09
+PT1rJiZhLmI8PTAmJiFDLnhCLlFpKGwsIi8iLG4pKXtvLT1qKjMKaD0iIn1wPW0tbytoLmxlbmd0aApy
+ZXR1cm4gbmV3IFAuVWYoQy54Qi5OaihsLDAsbSkraCtDLnhCLnluKHMsbyksYS5iLGEuYyxhLmQsbixn
+K3AsYi5yK3AsYS54KX0sCnQ0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHA9dGhpcwppZihwLmI+PTAmJiFw
+LmdOdygpKXRocm93IEguYihQLkw0KCJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0aCBmcm9tIGEgIitw
+LmdGaSgpKyIgVVJJIikpCnM9cC5mCnI9cC5hCmlmKHM8ci5sZW5ndGgpe2lmKHM8cC5yKXRocm93IEgu
+YihQLkw0KHUuaSkpCnRocm93IEguYihQLkw0KHUubCkpfXE9JC53USgpCmlmKEgub1QocSkpcz1QLm1u
+KHApCmVsc2V7aWYocC5jPHAuZClILnYoUC5MNCh1LmopKQpzPUMueEIuTmoocixwLmUscyl9cmV0dXJu
+IHN9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHM9dGhpcy55CnJldHVybiBzPT1udWxsP3RoaXMueT1DLnhC
+LmdpTyh0aGlzLmEpOnN9LApETjpmdW5jdGlvbihhLGIpe2lmKGI9PW51bGwpcmV0dXJuITEKaWYodGhp
+cz09PWIpcmV0dXJuITAKcmV0dXJuIHQuZEQuYihiKSYmdGhpcy5hPT09Yi53KDApfSwKdnM6ZnVuY3Rp
+b24oKXt2YXIgcz10aGlzLHI9bnVsbCxxPXMuZ0ZpKCkscD1zLmdrdSgpLG89cy5jPjA/cy5nSmYocyk6
+cixuPXMuZ3hBKCk/cy5ndHAocyk6cixtPXMuYSxsPXMuZixrPUMueEIuTmoobSxzLmUsbCksaj1zLnIK
+bD1sPGo/cy5ndFAoKTpyCnJldHVybiBuZXcgUC5EbihxLHAsbyxuLGssbCxqPG0ubGVuZ3RoP3MuZ0th
+KCk6cil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmF9LAokaWlEOjF9ClAucWUucHJvdG90eXBl
+PXt9ClcucUUucHJvdG90eXBlPXt9ClcuR2gucHJvdG90eXBlPXsKc0xVOmZ1bmN0aW9uKGEsYil7YS5o
+cmVmPWJ9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9LAokaUdoOjF9ClcuZlkucHJvdG90
+eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0KVy5uQi5wcm90b3R5cGU9eyRpbkI6
+MX0KVy5Bei5wcm90b3R5cGU9eyRpQXo6MX0KVy5RUC5wcm90b3R5cGU9eyRpUVA6MX0KVy5ueC5wcm90
+b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9fQpXLm9KLnByb3RvdHlwZT17CmdB
+OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19ClcuaWQucHJvdG90eXBlPXt9ClcuUUYucHJvdG90
+eXBlPXt9ClcuTmgucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gU3RyaW5nKGEpfX0KVy5h
+ZS5wcm90b3R5cGU9ewpEYzpmdW5jdGlvbihhLGIpe3JldHVybiBhLmNyZWF0ZUhUTUxEb2N1bWVudChi
+KX19ClcuSUIucHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXt2YXIgcyxyPWEubGVmdApyLnRvU3RyaW5n
+CnI9IlJlY3RhbmdsZSAoIitILkVqKHIpKyIsICIKcz1hLnRvcApzLnRvU3RyaW5nCnM9citILkVqKHMp
+KyIpICIKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1zK0guRWoocikrIiB4ICIKcz1hLmhlaWdodApzLnRv
+U3RyaW5nCnJldHVybiByK0guRWoocyl9LApETjpmdW5jdGlvbihhLGIpe3ZhciBzLHIKaWYoYj09bnVs
+bClyZXR1cm4hMQppZih0LnEuYihiKSl7cz1hLmxlZnQKcy50b1N0cmluZwpyPWIubGVmdApyLnRvU3Ry
+aW5nCmlmKHM9PT1yKXtzPWEudG9wCnMudG9TdHJpbmcKcj1iLnRvcApyLnRvU3RyaW5nCmlmKHM9PT1y
+KXtzPWEud2lkdGgKcy50b1N0cmluZwpyPWIud2lkdGgKci50b1N0cmluZwppZihzPT09cil7cz1hLmhl
+aWdodApzLnRvU3RyaW5nCnI9Yi5oZWlnaHQKci50b1N0cmluZwpyPXM9PT1yCnM9cn1lbHNlIHM9ITF9
+ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITEKcmV0dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7dmFy
+IHMscixxLHA9YS5sZWZ0CnAudG9TdHJpbmcKcD1DLkNELmdpTyhwKQpzPWEudG9wCnMudG9TdHJpbmcK
+cz1DLkNELmdpTyhzKQpyPWEud2lkdGgKci50b1N0cmluZwpyPUMuQ0QuZ2lPKHIpCnE9YS5oZWlnaHQK
+cS50b1N0cmluZwpyZXR1cm4gVy5yRShwLHMscixDLkNELmdpTyhxKSl9LAokaXRuOjF9ClcubjcucHJv
+dG90eXBlPXsKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RofX0KVy53ei5wcm90b3R5cGU9ewpn
+QTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5hLmxlbmd0aH0sCnE6ZnVuY3Rpb24oYSxiKXt2YXIgcwpI
+LnVQKGIpCnM9dGhpcy5hCmlmKGI8MHx8Yj49cy5sZW5ndGgpcmV0dXJuIEguT0gocyxiKQpyZXR1cm4g
+dGhpcy4kdGkuYy5hKHNbYl0pfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuJHRpLmMuYShjKQp0aHJv
+dyBILmIoUC5MNCgiQ2Fubm90IG1vZGlmeSBsaXN0IikpfX0KVy5jdi5wcm90b3R5cGU9ewpnUWc6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIG5ldyBXLmk3KGEpfSwKZ246ZnVuY3Rpb24oYSl7cmV0dXJuIG5ldyBXLkk0
+KGEpfSwKc246ZnVuY3Rpb24oYSxiKXt2YXIgcwp0LlEuYShiKQpzPXRoaXMuZ24oYSkKcy5WMSgwKQpz
+LkZWKDAsYil9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBhLmxvY2FsTmFtZX0sCkZGOmZ1bmN0aW9uKGEp
+e3ZhciBzPSEhYS5zY3JvbGxJbnRvVmlld0lmTmVlZGVkCmlmKHMpYS5zY3JvbGxJbnRvVmlld0lmTmVl
+ZGVkKCkKZWxzZSBhLnNjcm9sbEludG9WaWV3KCl9LApuejpmdW5jdGlvbihhLGIsYyxkLGUpe3ZhciBz
+LHI9dGhpcy5yNihhLGMsZCxlKQpzd2l0Y2goYi50b0xvd2VyQ2FzZSgpKXtjYXNlImJlZm9yZWJlZ2lu
+IjpzPWEucGFyZW50Tm9kZQpzLnRvU3RyaW5nCkouRWgocyxyLGEpCmJyZWFrCmNhc2UiYWZ0ZXJiZWdp
+biI6cz1hLmNoaWxkTm9kZXMKdGhpcy5tSyhhLHIscy5sZW5ndGg+MD9zWzBdOm51bGwpCmJyZWFrCmNh
+c2UiYmVmb3JlZW5kIjphLmFwcGVuZENoaWxkKHIpCmJyZWFrCmNhc2UiYWZ0ZXJlbmQiOnM9YS5wYXJl
+bnROb2RlCnMudG9TdHJpbmcKSi5FaChzLHIsYS5uZXh0U2libGluZykKYnJlYWsKZGVmYXVsdDpILnYo
+UC54WSgiSW52YWxpZCBwb3NpdGlvbiAiK2IpKX19LApyNjpmdW5jdGlvbihhLGIsYyxkKXt2YXIgcyxy
+LHEscAppZihjPT1udWxsKXtpZihkPT1udWxsKXtzPSQubHQKaWYocz09bnVsbCl7cz1ILlZNKFtdLHQu
+dikKcj1uZXcgVy52RChzKQpDLk5tLmkocyxXLlR3KG51bGwpKQpDLk5tLmkocyxXLkJsKCkpCiQubHQ9
+cgpkPXJ9ZWxzZSBkPXN9cz0kLkVVCmlmKHM9PW51bGwpe3M9bmV3IFcuS28oZCkKJC5FVT1zCmM9c31l
+bHNle3MuYT1kCmM9c319ZWxzZSBpZihkIT1udWxsKXRocm93IEguYihQLnhZKCJ2YWxpZGF0b3IgY2Fu
+IG9ubHkgYmUgcGFzc2VkIGlmIHRyZWVTYW5pdGl6ZXIgaXMgbnVsbCIpKQppZigkLnhvPT1udWxsKXtz
+PWRvY3VtZW50CnI9cy5pbXBsZW1lbnRhdGlvbgpyLnRvU3RyaW5nCnI9Qy5tSC5EYyhyLCIiKQokLnhv
+PXIKJC5CTz1yLmNyZWF0ZVJhbmdlKCkKcj0kLnhvLmNyZWF0ZUVsZW1lbnQoImJhc2UiKQp0LmNSLmEo
+cikKcz1zLmJhc2VVUkkKcy50b1N0cmluZwpyLmhyZWY9cwokLnhvLmhlYWQuYXBwZW5kQ2hpbGQocil9
+cz0kLnhvCmlmKHMuYm9keT09bnVsbCl7cj1zLmNyZWF0ZUVsZW1lbnQoImJvZHkiKQpDLkJaLnNYRyhz
+LHQucC5hKHIpKX1zPSQueG8KaWYodC5wLmIoYSkpe3M9cy5ib2R5CnMudG9TdHJpbmcKcT1zfWVsc2V7
+cy50b1N0cmluZwpxPXMuY3JlYXRlRWxlbWVudChhLnRhZ05hbWUpCiQueG8uYm9keS5hcHBlbmRDaGls
+ZChxKX1pZigiY3JlYXRlQ29udGV4dHVhbEZyYWdtZW50IiBpbiB3aW5kb3cuUmFuZ2UucHJvdG90eXBl
+JiYhQy5ObS50ZyhDLlNxLGEudGFnTmFtZSkpeyQuQk8uc2VsZWN0Tm9kZUNvbnRlbnRzKHEpCnM9JC5C
+TwpzLnRvU3RyaW5nCnA9cy5jcmVhdGVDb250ZXh0dWFsRnJhZ21lbnQoYj09bnVsbD8ibnVsbCI6Yil9
+ZWxzZXtKLndmKHEsYikKcD0kLnhvLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpmb3IoO3M9cS5maXJz
+dENoaWxkLHMhPW51bGw7KXAuYXBwZW5kQ2hpbGQocyl9aWYocSE9PSQueG8uYm9keSlKLkx0KHEpCmMu
+UG4ocCkKZG9jdW1lbnQuYWRvcHROb2RlKHApCnJldHVybiBwfSwKQUg6ZnVuY3Rpb24oYSxiLGMpe3Jl
+dHVybiB0aGlzLnI2KGEsYixjLG51bGwpfSwKc2hmOmZ1bmN0aW9uKGEsYil7dGhpcy5ZQyhhLGIpfSwK
+cGs6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuc2E0KGEsbnVsbCkKYS5hcHBlbmRDaGlsZCh0aGlzLnI2KGEs
+YixudWxsLGMpKX0sCllDOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMucGsoYSxiLG51bGwpfSwKc1JO
+OmZ1bmN0aW9uKGEsYil7YS5pbm5lckhUTUw9Yn0sCmduczpmdW5jdGlvbihhKXtyZXR1cm4gYS50YWdO
+YW1lfSwKZ1ZsOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5ldShhLCJjbGljayIsITEsdC5rKX0sCiRp
+Y3Y6MX0KVy5Ddi5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5oLmIodC5BLmEoYSkp
+fSwKJFM6MjV9ClcuZWEucHJvdG90eXBlPXskaWVhOjF9ClcuRDAucHJvdG90eXBlPXsKT246ZnVuY3Rp
+b24oYSxiLGMsZCl7dC5idy5hKGMpCmlmKGMhPW51bGwpdGhpcy52KGEsYixjLGQpfSwKQjpmdW5jdGlv
+bihhLGIsYyl7cmV0dXJuIHRoaXMuT24oYSxiLGMsbnVsbCl9LAp2OmZ1bmN0aW9uKGEsYixjLGQpe3Jl
+dHVybiBhLmFkZEV2ZW50TGlzdGVuZXIoYixILnRSKHQuYncuYShjKSwxKSxkKX0sCiRpRDA6MX0KVy5o
+SC5wcm90b3R5cGU9eyRpaEg6MX0KVy5oNC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4g
+YS5sZW5ndGh9fQpXLmJyLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH19
+ClcuVmIucHJvdG90eXBlPXsKc1hHOmZ1bmN0aW9uKGEsYil7YS5ib2R5PWJ9fQpXLmZKLnByb3RvdHlw
+ZT17CmVvOmZ1bmN0aW9uKGEsYixjLGQpe3JldHVybiBhLm9wZW4oYixjLCEwKX0sCiRpZko6MX0KVy53
+YS5wcm90b3R5cGU9e30KVy5TZy5wcm90b3R5cGU9eyRpU2c6MX0KVy53Ny5wcm90b3R5cGU9ewpnRHI6
+ZnVuY3Rpb24oYSl7aWYoIm9yaWdpbiIgaW4gYSlyZXR1cm4gYS5vcmlnaW4KcmV0dXJuIEguRWooYS5w
+cm90b2NvbCkrIi8vIitILkVqKGEuaG9zdCl9LAp3OmZ1bmN0aW9uKGEpe3JldHVybiBTdHJpbmcoYSl9
+LAokaXc3OjF9ClcuQWoucHJvdG90eXBlPXskaUFqOjF9ClcuZTcucHJvdG90eXBlPXsKZ3I4OmZ1bmN0
+aW9uKGEpe3ZhciBzPXRoaXMuYSxyPXMuY2hpbGROb2Rlcy5sZW5ndGgKaWYocj09PTApdGhyb3cgSC5i
+KFAuUFYoIk5vIGVsZW1lbnRzIikpCmlmKHI+MSl0aHJvdyBILmIoUC5QVigiTW9yZSB0aGFuIG9uZSBl
+bGVtZW50IikpCnM9cy5maXJzdENoaWxkCnMudG9TdHJpbmcKcmV0dXJuIHN9LApGVjpmdW5jdGlvbihh
+LGIpe3ZhciBzLHIscSxwLG8KdC5laC5hKGIpCmlmKGIgaW5zdGFuY2VvZiBXLmU3KXtzPWIuYQpyPXRo
+aXMuYQppZihzIT09cilmb3IocT1zLmNoaWxkTm9kZXMubGVuZ3RoLHA9MDtwPHE7KytwKXtvPXMuZmly
+c3RDaGlsZApvLnRvU3RyaW5nCnIuYXBwZW5kQ2hpbGQobyl9cmV0dXJufWZvcihzPWIuZ20oYikscj10
+aGlzLmE7cy5GKCk7KXIuYXBwZW5kQ2hpbGQocy5nbCgpKX0sClk1OmZ1bmN0aW9uKGEsYixjKXt2YXIg
+cyxyCnQuQS5hKGMpCnM9dGhpcy5hCnI9cy5jaGlsZE5vZGVzCmlmKGI8MHx8Yj49ci5sZW5ndGgpcmV0
+dXJuIEguT0gocixiKQpzLnJlcGxhY2VDaGlsZChjLHJbYl0pfSwKZ206ZnVuY3Rpb24oYSl7dmFyIHM9
+dGhpcy5hLmNoaWxkTm9kZXMKcmV0dXJuIG5ldyBXLlc5KHMscy5sZW5ndGgsSC56KHMpLkMoIlc5PEdt
+LkU+IikpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jaGlsZE5vZGVzLmxlbmd0aH0sCnE6
+ZnVuY3Rpb24oYSxiKXt2YXIgcwpILnVQKGIpCnM9dGhpcy5hLmNoaWxkTm9kZXMKaWYoYjwwfHxiPj1z
+Lmxlbmd0aClyZXR1cm4gSC5PSChzLGIpCnJldHVybiBzW2JdfX0KVy51SC5wcm90b3R5cGU9ewp3Zzpm
+dW5jdGlvbihhKXt2YXIgcz1hLnBhcmVudE5vZGUKaWYocyE9bnVsbClzLnJlbW92ZUNoaWxkKGEpfSwK
+RDQ6ZnVuY3Rpb24oYSl7dmFyIHMKZm9yKDtzPWEuZmlyc3RDaGlsZCxzIT1udWxsOylhLnJlbW92ZUNo
+aWxkKHMpfSwKdzpmdW5jdGlvbihhKXt2YXIgcz1hLm5vZGVWYWx1ZQpyZXR1cm4gcz09bnVsbD90aGlz
+LlUoYSk6c30sCnNhNDpmdW5jdGlvbihhLGIpe2EudGV4dENvbnRlbnQ9Yn0sCm1LOmZ1bmN0aW9uKGEs
+YixjKXtyZXR1cm4gYS5pbnNlcnRCZWZvcmUoYixjKX0sCiRpdUg6MX0KVy5CSC5wcm90b3R5cGU9ewpn
+QTpmdW5jdGlvbihhKXtyZXR1cm4gYS5sZW5ndGh9LApxOmZ1bmN0aW9uKGEsYil7SC51UChiKQppZihi
+Pj4+MCE9PWJ8fGI+PWEubGVuZ3RoKXRocm93IEguYihQLkNmKGIsYSxudWxsLG51bGwsbnVsbCkpCnJl
+dHVybiBhW2JdfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3QuQS5hKGMpCnRocm93IEguYihQLkw0KCJDYW5u
+b3QgYXNzaWduIGVsZW1lbnQgb2YgaW1tdXRhYmxlIExpc3QuIikpfSwKZ3RIOmZ1bmN0aW9uKGEpe2lm
+KGEubGVuZ3RoPjApcmV0dXJuIGFbMF0KdGhyb3cgSC5iKFAuUFYoIk5vIGVsZW1lbnRzIikpfSwKRTpm
+dW5jdGlvbihhLGIpe2lmKGI8MHx8Yj49YS5sZW5ndGgpcmV0dXJuIEguT0goYSxiKQpyZXR1cm4gYVti
+XX0sCiRpYlE6MSwKJGlYajoxLAokaWNYOjEsCiRpek06MX0KVy5TTi5wcm90b3R5cGU9e30KVy5ldy5w
+cm90b3R5cGU9eyRpZXc6MX0KVy5scC5wcm90b3R5cGU9ewpnQTpmdW5jdGlvbihhKXtyZXR1cm4gYS5s
+ZW5ndGh9fQpXLlRiLnByb3RvdHlwZT17CnI2OmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIKaWYoImNy
+ZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnByb3RvdHlwZSlyZXR1cm4gdGhp
+cy5EVyhhLGIsYyxkKQpzPVcuVTkoIjx0YWJsZT4iK0guRWooYikrIjwvdGFibGU+IixjLGQpCnI9ZG9j
+dW1lbnQuY3JlYXRlRG9jdW1lbnRGcmFnbWVudCgpCnIudG9TdHJpbmcKcy50b1N0cmluZwpuZXcgVy5l
+NyhyKS5GVigwLG5ldyBXLmU3KHMpKQpyZXR1cm4gcn19ClcuSXYucHJvdG90eXBlPXsKcjY6ZnVuY3Rp
+b24oYSxiLGMsZCl7dmFyIHMscixxLHAKaWYoImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2lu
+ZG93LlJhbmdlLnByb3RvdHlwZSlyZXR1cm4gdGhpcy5EVyhhLGIsYyxkKQpzPWRvY3VtZW50CnI9cy5j
+cmVhdGVEb2N1bWVudEZyYWdtZW50KCkKcz1DLkllLnI2KHMuY3JlYXRlRWxlbWVudCgidGFibGUiKSxi
+LGMsZCkKcy50b1N0cmluZwpzPW5ldyBXLmU3KHMpCnE9cy5ncjgocykKcS50b1N0cmluZwpzPW5ldyBX
+LmU3KHEpCnA9cy5ncjgocykKci50b1N0cmluZwpwLnRvU3RyaW5nCm5ldyBXLmU3KHIpLkZWKDAsbmV3
+IFcuZTcocCkpCnJldHVybiByfX0KVy5XUC5wcm90b3R5cGU9ewpyNjpmdW5jdGlvbihhLGIsYyxkKXt2
+YXIgcyxyLHEKaWYoImNyZWF0ZUNvbnRleHR1YWxGcmFnbWVudCIgaW4gd2luZG93LlJhbmdlLnByb3Rv
+dHlwZSlyZXR1cm4gdGhpcy5EVyhhLGIsYyxkKQpzPWRvY3VtZW50CnI9cy5jcmVhdGVEb2N1bWVudEZy
+YWdtZW50KCkKcz1DLkllLnI2KHMuY3JlYXRlRWxlbWVudCgidGFibGUiKSxiLGMsZCkKcy50b1N0cmlu
+ZwpzPW5ldyBXLmU3KHMpCnE9cy5ncjgocykKci50b1N0cmluZwpxLnRvU3RyaW5nCm5ldyBXLmU3KHIp
+LkZWKDAsbmV3IFcuZTcocSkpCnJldHVybiByfX0KVy55WS5wcm90b3R5cGU9ewpwazpmdW5jdGlvbihh
+LGIsYyl7dmFyIHMscgp0aGlzLnNhNChhLG51bGwpCnM9YS5jb250ZW50CnMudG9TdHJpbmcKSi5iVChz
+KQpyPXRoaXMucjYoYSxiLG51bGwsYykKYS5jb250ZW50LmFwcGVuZENoaWxkKHIpfSwKWUM6ZnVuY3Rp
+b24oYSxiKXtyZXR1cm4gdGhpcy5wayhhLGIsbnVsbCl9LAokaXlZOjF9ClcudzYucHJvdG90eXBlPXt9
+ClcuSzUucHJvdG90eXBlPXsKUG86ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPVcuUDEoYS5vcGVuKGIsYykp
+CnJldHVybiBzfSwKZ21XOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxvY2F0aW9ufSwKdXM6ZnVuY3Rpb24o
+YSxiKXtyZXR1cm4gYS5jb25maXJtKGIpfSwKJGlLNToxLAokaXY2OjF9ClcuQ20ucHJvdG90eXBlPXsk
+aUNtOjF9ClcuQ1EucHJvdG90eXBlPXskaUNROjF9ClcudzQucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
+KXt2YXIgcyxyPWEubGVmdApyLnRvU3RyaW5nCnI9IlJlY3RhbmdsZSAoIitILkVqKHIpKyIsICIKcz1h
+LnRvcApzLnRvU3RyaW5nCnM9citILkVqKHMpKyIpICIKcj1hLndpZHRoCnIudG9TdHJpbmcKcj1zK0gu
+RWoocikrIiB4ICIKcz1hLmhlaWdodApzLnRvU3RyaW5nCnJldHVybiByK0guRWoocyl9LApETjpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIKaWYoYj09bnVsbClyZXR1cm4hMQppZih0LnEuYihiKSl7cz1hLmxlZnQK
+cy50b1N0cmluZwpyPWIubGVmdApyLnRvU3RyaW5nCmlmKHM9PT1yKXtzPWEudG9wCnMudG9TdHJpbmcK
+cj1iLnRvcApyLnRvU3RyaW5nCmlmKHM9PT1yKXtzPWEud2lkdGgKcy50b1N0cmluZwpyPWIud2lkdGgK
+ci50b1N0cmluZwppZihzPT09cil7cz1hLmhlaWdodApzLnRvU3RyaW5nCnI9Yi5oZWlnaHQKci50b1N0
+cmluZwpyPXM9PT1yCnM9cn1lbHNlIHM9ITF9ZWxzZSBzPSExfWVsc2Ugcz0hMX1lbHNlIHM9ITEKcmV0
+dXJuIHN9LApnaU86ZnVuY3Rpb24oYSl7dmFyIHMscixxLHA9YS5sZWZ0CnAudG9TdHJpbmcKcD1DLkNE
+LmdpTyhwKQpzPWEudG9wCnMudG9TdHJpbmcKcz1DLkNELmdpTyhzKQpyPWEud2lkdGgKci50b1N0cmlu
+ZwpyPUMuQ0QuZ2lPKHIpCnE9YS5oZWlnaHQKcS50b1N0cmluZwpyZXR1cm4gVy5yRShwLHMscixDLkNE
+LmdpTyhxKSl9fQpXLnJoLnByb3RvdHlwZT17CmdBOmZ1bmN0aW9uKGEpe3JldHVybiBhLmxlbmd0aH0s
+CnE6ZnVuY3Rpb24oYSxiKXtILnVQKGIpCmlmKGI+Pj4wIT09Ynx8Yj49YS5sZW5ndGgpdGhyb3cgSC5i
+KFAuQ2YoYixhLG51bGwsbnVsbCxudWxsKSkKcmV0dXJuIGFbYl19LApZNTpmdW5jdGlvbihhLGIsYyl7
+dC5BLmEoYykKdGhyb3cgSC5iKFAuTDQoIkNhbm5vdCBhc3NpZ24gZWxlbWVudCBvZiBpbW11dGFibGUg
+TGlzdC4iKSl9LApFOmZ1bmN0aW9uKGEsYil7aWYoYjwwfHxiPj1hLmxlbmd0aClyZXR1cm4gSC5PSChh
+LGIpCnJldHVybiBhW2JdfSwKJGliUToxLAokaVhqOjEsCiRpY1g6MSwKJGl6TToxfQpXLmNmLnByb3Rv
+dHlwZT17Cks6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvCnQuZUEuYShiKQpmb3Iocz10aGlzLmd2
+YygpLHI9cy5sZW5ndGgscT10aGlzLmEscD0wO3A8cy5sZW5ndGg7cy5sZW5ndGg9PT1yfHwoMCxILmxr
+KShzKSwrK3Ape289c1twXQpiLiQyKG8scS5nZXRBdHRyaWJ1dGUobykpfX0sCmd2YzpmdW5jdGlvbigp
+e3ZhciBzLHIscSxwLG8sbixtPXRoaXMuYS5hdHRyaWJ1dGVzCm0udG9TdHJpbmcKcz1ILlZNKFtdLHQu
+cykKZm9yKHI9bS5sZW5ndGgscT10Lmg5LHA9MDtwPHI7KytwKXtpZihwPj1tLmxlbmd0aClyZXR1cm4g
+SC5PSChtLHApCm89cS5hKG1bcF0pCmlmKG8ubmFtZXNwYWNlVVJJPT1udWxsKXtuPW8ubmFtZQpuLnRv
+U3RyaW5nCkMuTm0uaShzLG4pfX1yZXR1cm4gc30sCmdsMDpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5n
+dmMoKS5sZW5ndGg9PT0wfX0KVy5pNy5wcm90b3R5cGU9ewp4NDpmdW5jdGlvbihhKXt2YXIgcz1ILm9U
+KHRoaXMuYS5oYXNBdHRyaWJ1dGUoYSkpCnJldHVybiBzfSwKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0
+aGlzLmEuZ2V0QXR0cmlidXRlKEguaChiKSl9LApZNTpmdW5jdGlvbihhLGIsYyl7dGhpcy5hLnNldEF0
+dHJpYnV0ZShiLGMpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3RofX0KVy5T
+eS5wcm90b3R5cGU9ewp4NDpmdW5jdGlvbihhKXt2YXIgcz1ILm9UKHRoaXMuYS5hLmhhc0F0dHJpYnV0
+ZSgiZGF0YS0iK3RoaXMuUChhKSkpCnJldHVybiBzfSwKcTpmdW5jdGlvbihhLGIpe3JldHVybiB0aGlz
+LmEuYS5nZXRBdHRyaWJ1dGUoImRhdGEtIit0aGlzLlAoSC5oKGIpKSl9LApZNTpmdW5jdGlvbihhLGIs
+Yyl7dGhpcy5hLmEuc2V0QXR0cmlidXRlKCJkYXRhLSIrdGhpcy5QKGIpLGMpfSwKSzpmdW5jdGlvbihh
+LGIpe3RoaXMuYS5LKDAsbmV3IFcuS1ModGhpcyx0LmVBLmEoYikpKX0sCmd2YzpmdW5jdGlvbigpe3Zh
+ciBzPUguVk0oW10sdC5zKQp0aGlzLmEuSygwLG5ldyBXLkEzKHRoaXMscykpCnJldHVybiBzfSwKZ0E6
+ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuZ3ZjKCkubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVy
+biB0aGlzLmd2YygpLmxlbmd0aD09PTB9LAp4cTpmdW5jdGlvbihhKXt2YXIgcyxyLHE9SC5WTShhLnNw
+bGl0KCItIiksdC5zKQpmb3Iocz0xO3M8cS5sZW5ndGg7KytzKXtyPXFbc10KaWYoci5sZW5ndGg+MClD
+Lk5tLlk1KHEscyxyWzBdLnRvVXBwZXJDYXNlKCkrSi5LVihyLDEpKX1yZXR1cm4gQy5ObS5rKHEsIiIp
+fSwKUDpmdW5jdGlvbihhKXt2YXIgcyxyLHEscCxvCmZvcihzPWEubGVuZ3RoLHI9MCxxPSIiO3I8czsr
+K3Ipe3A9YVtyXQpvPXAudG9Mb3dlckNhc2UoKQpxPShwIT09byYmcj4wP3ErIi0iOnEpK299cmV0dXJu
+IHEuY2hhckNvZGVBdCgwKT09MD9xOnF9fQpXLktTLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7
+aWYoSi5yWShhKS5uQyhhLCJkYXRhLSIpKXRoaXMuYi4kMih0aGlzLmEueHEoQy54Qi55bihhLDUpKSxi
+KX0sCiRTOjE0fQpXLkEzLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7aWYoSi5yWShhKS5uQyhh
+LCJkYXRhLSIpKUMuTm0uaSh0aGlzLmIsdGhpcy5hLnhxKEMueEIueW4oYSw1KSkpfSwKJFM6MTR9Clcu
+STQucHJvdG90eXBlPXsKRDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89UC5Mcyh0Lk4pCmZvcihzPXRo
+aXMuYS5jbGFzc05hbWUuc3BsaXQoIiAiKSxyPXMubGVuZ3RoLHE9MDtxPHI7KytxKXtwPUouVDAoc1tx
+XSkKaWYocC5sZW5ndGghPT0wKW8uaSgwLHApfXJldHVybiBvfSwKWDpmdW5jdGlvbihhKXt0aGlzLmEu
+Y2xhc3NOYW1lPXQuQy5hKGEpLmsoMCwiICIpfSwKZ0E6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5j
+bGFzc0xpc3QubGVuZ3RofSwKZ2wwOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLmEuY2xhc3NMaXN0Lmxl
+bmd0aD09PTB9LApnb3I6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS5jbGFzc0xpc3QubGVuZ3RoIT09
+MH0sClYxOmZ1bmN0aW9uKGEpe3RoaXMuYS5jbGFzc05hbWU9IiJ9LAp0ZzpmdW5jdGlvbihhLGIpe3Zh
+ciBzPXRoaXMuYS5jbGFzc0xpc3QuY29udGFpbnMoYikKcmV0dXJuIHN9LAppOmZ1bmN0aW9uKGEsYil7
+dmFyIHMscgpILmgoYikKcz10aGlzLmEuY2xhc3NMaXN0CnI9cy5jb250YWlucyhiKQpzLmFkZChiKQpy
+ZXR1cm4hcn0sCkw6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEKaWYodHlwZW9mIGI9PSJzdHJpbmciKXtz
+PXRoaXMuYS5jbGFzc0xpc3QKcj1zLmNvbnRhaW5zKGIpCnMucmVtb3ZlKGIpCnE9cn1lbHNlIHE9ITEK
+cmV0dXJuIHF9LApGVjpmdW5jdGlvbihhLGIpe1cuVE4odGhpcy5hLHQuUS5hKGIpKX19ClcuRmsucHJv
+dG90eXBlPXt9ClcuUk8ucHJvdG90eXBlPXt9ClcuZXUucHJvdG90eXBlPXt9ClcueEMucHJvdG90eXBl
+PXt9Clcudk4ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYS4kMSh0LkIuYShh
+KSl9LAokUzoyN30KVy5KUS5wcm90b3R5cGU9ewpDWTpmdW5jdGlvbihhKXt2YXIgcwppZigkLm9yLmE9
+PT0wKXtmb3Iocz0wO3M8MjYyOysrcykkLm9yLlk1KDAsQy5jbVtzXSxXLnBTKCkpCmZvcihzPTA7czwx
+MjsrK3MpJC5vci5ZNSgwLEMuQklbc10sVy5WNCgpKX19LAppMDpmdW5jdGlvbihhKXtyZXR1cm4gJC5B
+TigpLnRnKDAsVy5yUyhhKSl9LApFYjpmdW5jdGlvbihhLGIsYyl7dmFyIHM9JC5vci5xKDAsSC5FaihX
+LnJTKGEpKSsiOjoiK2IpCmlmKHM9PW51bGwpcz0kLm9yLnEoMCwiKjo6IitiKQppZihzPT1udWxsKXJl
+dHVybiExCnJldHVybiBILnk4KHMuJDQoYSxiLGMsdGhpcykpfSwKJGlrRjoxfQpXLkdtLnByb3RvdHlw
+ZT17CmdtOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5XOShhLHRoaXMuZ0EoYSksSC56KGEpLkMoIlc5
+PEdtLkU+IikpfX0KVy52RC5wcm90b3R5cGU9ewppMDpmdW5jdGlvbihhKXtyZXR1cm4gQy5ObS5Wcih0
+aGlzLmEsbmV3IFcuVXYoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3JldHVybiBDLk5tLlZyKHRoaXMu
+YSxuZXcgVy5FZyhhLGIsYykpfSwKJGlrRjoxfQpXLlV2LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEp
+e3JldHVybiB0LkUuYShhKS5pMCh0aGlzLmEpfSwKJFM6MTV9ClcuRWcucHJvdG90eXBlPXsKJDE6ZnVu
+Y3Rpb24oYSl7cmV0dXJuIHQuRS5hKGEpLkViKHRoaXMuYSx0aGlzLmIsdGhpcy5jKX0sCiRTOjE1fQpX
+Lm02LnByb3RvdHlwZT17CkNZOmZ1bmN0aW9uKGEsYixjLGQpe3ZhciBzLHIscQp0aGlzLmEuRlYoMCxj
+KQpzPWIuZXYoMCxuZXcgVy5FbygpKQpyPWIuZXYoMCxuZXcgVy5XaygpKQp0aGlzLmIuRlYoMCxzKQpx
+PXRoaXMuYwpxLkZWKDAsQy54RCkKcS5GVigwLHIpfSwKaTA6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMu
+YS50ZygwLFcuclMoYSkpfSwKRWI6ZnVuY3Rpb24oYSxiLGMpe3ZhciBzPXRoaXMscj1XLnJTKGEpLHE9
+cy5jCmlmKHEudGcoMCxILkVqKHIpKyI6OiIrYikpcmV0dXJuIHMuZC5EdChjKQplbHNlIGlmKHEudGco
+MCwiKjo6IitiKSlyZXR1cm4gcy5kLkR0KGMpCmVsc2V7cT1zLmIKaWYocS50ZygwLEguRWoocikrIjo6
+IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6IitiKSlyZXR1cm4hMAplbHNlIGlmKHEudGco
+MCxILkVqKHIpKyI6OioiKSlyZXR1cm4hMAplbHNlIGlmKHEudGcoMCwiKjo6KiIpKXJldHVybiEwfXJl
+dHVybiExfSwKJGlrRjoxfQpXLkVvLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiFDLk5t
+LnRnKEMuQkksSC5oKGEpKX0sCiRTOjZ9ClcuV2sucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0
+dXJuIEMuTm0udGcoQy5CSSxILmgoYSkpfSwKJFM6Nn0KVy5jdC5wcm90b3R5cGU9ewpFYjpmdW5jdGlv
+bihhLGIsYyl7aWYodGhpcy5qRihhLGIsYykpcmV0dXJuITAKaWYoYj09PSJ0ZW1wbGF0ZSImJmM9PT0i
+IilyZXR1cm4hMAppZihhLmdldEF0dHJpYnV0ZSgidGVtcGxhdGUiKT09PSIiKXJldHVybiB0aGlzLmUu
+dGcoMCxiKQpyZXR1cm4hMX19ClcuSUEucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7cmV0dXJuIlRF
+TVBMQVRFOjoiK0guRWooSC5oKGEpKX0sCiRTOjV9ClcuT3cucHJvdG90eXBlPXsKaTA6ZnVuY3Rpb24o
+YSl7dmFyIHMKaWYodC5ldy5iKGEpKXJldHVybiExCnM9dC5nNy5iKGEpCmlmKHMmJlcuclMoYSk9PT0i
+Zm9yZWlnbk9iamVjdCIpcmV0dXJuITEKaWYocylyZXR1cm4hMApyZXR1cm4hMX0sCkViOmZ1bmN0aW9u
+KGEsYixjKXtpZihiPT09ImlzInx8Qy54Qi5uQyhiLCJvbiIpKXJldHVybiExCnJldHVybiB0aGlzLmkw
+KGEpfSwKJGlrRjoxfQpXLlc5LnByb3RvdHlwZT17CkY6ZnVuY3Rpb24oKXt2YXIgcz10aGlzLHI9cy5j
+KzEscT1zLmIKaWYocjxxKXtzLnNwKEoueDkocy5hLHIpKQpzLmM9cgpyZXR1cm4hMH1zLnNwKG51bGwp
+CnMuYz1xCnJldHVybiExfSwKZ2w6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5kfSwKc3A6ZnVuY3Rpb24o
+YSl7dGhpcy5kPXRoaXMuJHRpLkMoIjE/IikuYShhKX0sCiRpQW46MX0KVy5kVy5wcm90b3R5cGU9eyRp
+RDA6MSwkaXY2OjF9ClcubWsucHJvdG90eXBlPXskaXkwOjF9ClcuS28ucHJvdG90eXBlPXsKUG46ZnVu
+Y3Rpb24oYSl7dmFyIHM9dGhpcyxyPW5ldyBXLmZtKHMpCnMuYj0hMQpyLiQyKGEsbnVsbCkKZm9yKDtz
+LmI7KXtzLmI9ITEKci4kMihhLG51bGwpfX0sCkVQOmZ1bmN0aW9uKGEsYil7dmFyIHM9dGhpcy5iPSEw
+CmlmKGIhPW51bGw/YiE9PWEucGFyZW50Tm9kZTpzKUouTHQoYSkKZWxzZSBiLnJlbW92ZUNoaWxkKGEp
+fSwKSTQ6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG49ITAsbT1udWxsLGw9bnVsbAp0cnl7bT1K
+LmlnKGEpCmw9bS5hLmdldEF0dHJpYnV0ZSgiaXMiKQp0LmguYShhKQpzPWZ1bmN0aW9uKGMpe2lmKCEo
+Yy5hdHRyaWJ1dGVzIGluc3RhbmNlb2YgTmFtZWROb2RlTWFwKSlyZXR1cm4gdHJ1ZQppZihjLmlkPT0n
+bGFzdENoaWxkJ3x8Yy5uYW1lPT0nbGFzdENoaWxkJ3x8Yy5pZD09J3ByZXZpb3VzU2libGluZyd8fGMu
+bmFtZT09J3ByZXZpb3VzU2libGluZyd8fGMuaWQ9PSdjaGlsZHJlbid8fGMubmFtZT09J2NoaWxkcmVu
+JylyZXR1cm4gdHJ1ZQp2YXIgaz1jLmNoaWxkTm9kZXMKaWYoYy5sYXN0Q2hpbGQmJmMubGFzdENoaWxk
+IT09a1trLmxlbmd0aC0xXSlyZXR1cm4gdHJ1ZQppZihjLmNoaWxkcmVuKWlmKCEoYy5jaGlsZHJlbiBp
+bnN0YW5jZW9mIEhUTUxDb2xsZWN0aW9ufHxjLmNoaWxkcmVuIGluc3RhbmNlb2YgTm9kZUxpc3QpKXJl
+dHVybiB0cnVlCnZhciBqPTAKaWYoYy5jaGlsZHJlbilqPWMuY2hpbGRyZW4ubGVuZ3RoCmZvcih2YXIg
+aT0wO2k8ajtpKyspe3ZhciBoPWMuY2hpbGRyZW5baV0KaWYoaC5pZD09J2F0dHJpYnV0ZXMnfHxoLm5h
+bWU9PSdhdHRyaWJ1dGVzJ3x8aC5pZD09J2xhc3RDaGlsZCd8fGgubmFtZT09J2xhc3RDaGlsZCd8fGgu
+aWQ9PSdwcmV2aW91c1NpYmxpbmcnfHxoLm5hbWU9PSdwcmV2aW91c1NpYmxpbmcnfHxoLmlkPT0nY2hp
+bGRyZW4nfHxoLm5hbWU9PSdjaGlsZHJlbicpcmV0dXJuIHRydWV9cmV0dXJuIGZhbHNlfShhKQpuPUgu
+b1Qocyk/ITA6IShhLmF0dHJpYnV0ZXMgaW5zdGFuY2VvZiBOYW1lZE5vZGVNYXApfWNhdGNoKHApe0gu
+UnUocCl9cj0iZWxlbWVudCB1bnByaW50YWJsZSIKdHJ5e3I9Si5qKGEpfWNhdGNoKHApe0guUnUocCl9
+dHJ5e3E9Vy5yUyhhKQp0aGlzLmtSKHQuaC5hKGEpLGIsbixyLHEsdC5mLmEobSksSC5rKGwpKX1jYXRj
+aChwKXtpZihILlJ1KHApIGluc3RhbmNlb2YgUC51KXRocm93IHAKZWxzZXt0aGlzLkVQKGEsYikKd2lu
+ZG93Cm89IlJlbW92aW5nIGNvcnJ1cHRlZCBlbGVtZW50ICIrSC5FaihyKQppZih0eXBlb2YgY29uc29s
+ZSE9InVuZGVmaW5lZCIpd2luZG93LmNvbnNvbGUud2FybihvKX19fSwKa1I6ZnVuY3Rpb24oYSxiLGMs
+ZCxlLGYsZyl7dmFyIHMscixxLHAsbyxuLG09dGhpcwppZihjKXttLkVQKGEsYikKd2luZG93CnM9IlJl
+bW92aW5nIGVsZW1lbnQgZHVlIHRvIGNvcnJ1cHRlZCBhdHRyaWJ1dGVzIG9uIDwiK2QrIj4iCmlmKHR5
+cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKHMpCnJldHVybn1pZigh
+bS5hLmkwKGEpKXttLkVQKGEsYikKd2luZG93CnM9IlJlbW92aW5nIGRpc2FsbG93ZWQgZWxlbWVudCA8
+IitILkVqKGUpKyI+IGZyb20gIitILkVqKGIpCmlmKHR5cGVvZiBjb25zb2xlIT0idW5kZWZpbmVkIil3
+aW5kb3cuY29uc29sZS53YXJuKHMpCnJldHVybn1pZihnIT1udWxsKWlmKCFtLmEuRWIoYSwiaXMiLGcp
+KXttLkVQKGEsYikKd2luZG93CnM9IlJlbW92aW5nIGRpc2FsbG93ZWQgdHlwZSBleHRlbnNpb24gPCIr
+SC5FaihlKSsnIGlzPSInK2crJyI+JwppZih0eXBlb2YgY29uc29sZSE9InVuZGVmaW5lZCIpd2luZG93
+LmNvbnNvbGUud2FybihzKQpyZXR1cm59cz1mLmd2YygpCnI9SC5WTShzLnNsaWNlKDApLEgudDYocykp
+CmZvcihxPWYuZ3ZjKCkubGVuZ3RoLTEscz1mLmE7cT49MDstLXEpe2lmKHE+PXIubGVuZ3RoKXJldHVy
+biBILk9IKHIscSkKcD1yW3FdCm89bS5hCm49Si5jSChwKQpILmgocCkKaWYoIW8uRWIoYSxuLHMuZ2V0
+QXR0cmlidXRlKHApKSl7d2luZG93Cm89IlJlbW92aW5nIGRpc2FsbG93ZWQgYXR0cmlidXRlIDwiK0gu
+RWooZSkrIiAiK3ArJz0iJytILkVqKHMuZ2V0QXR0cmlidXRlKHApKSsnIj4nCmlmKHR5cGVvZiBjb25z
+b2xlIT0idW5kZWZpbmVkIil3aW5kb3cuY29uc29sZS53YXJuKG8pCnMucmVtb3ZlQXR0cmlidXRlKHAp
+fX1pZih0LmFXLmIoYSkpe3M9YS5jb250ZW50CnMudG9TdHJpbmcKbS5QbihzKX19LAokaW9uOjF9Clcu
+Zm0ucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbT10aGlzLmEKc3dp
+dGNoKGEubm9kZVR5cGUpe2Nhc2UgMTptLkk0KGEsYikKYnJlYWsKY2FzZSA4OmNhc2UgMTE6Y2FzZSAz
+OmNhc2UgNDpicmVhawpkZWZhdWx0Om0uRVAoYSxiKX1zPWEubGFzdENoaWxkCmZvcihxPXQuQTtudWxs
+IT1zOyl7cj1udWxsCnRyeXtyPXMucHJldmlvdXNTaWJsaW5nCmlmKHIhPW51bGwpe3A9ci5uZXh0U2li
+bGluZwpvPXMKbz1wPT1udWxsP28hPW51bGw6cCE9PW8KcD1vfWVsc2UgcD0hMQppZihwKXtwPVAuUFYo
+IkNvcnJ1cHQgSFRNTCIpCnRocm93IEguYihwKX19Y2F0Y2gobil7SC5SdShuKQpwPXEuYShzKQptLmI9
+ITAKbz1wLnBhcmVudE5vZGUKbz1hPT1udWxsP28hPW51bGw6YSE9PW8KaWYobyl7bz1wLnBhcmVudE5v
+ZGUKaWYobyE9bnVsbClvLnJlbW92ZUNoaWxkKHApfWVsc2UgYS5yZW1vdmVDaGlsZChwKQpzPW51bGwK
+cj1hLmxhc3RDaGlsZH1pZihzIT1udWxsKXRoaXMuJDIocyxhKQpzPXJ9fSwKJFM6MzB9ClcuTGUucHJv
+dG90eXBlPXt9ClcuSzcucHJvdG90eXBlPXt9ClcuckIucHJvdG90eXBlPXt9ClcuWFcucHJvdG90eXBl
+PXt9Clcub2EucHJvdG90eXBlPXt9ClAuaUoucHJvdG90eXBlPXsKVkg6ZnVuY3Rpb24oYSl7dmFyIHMs
+cj10aGlzLmEscT1yLmxlbmd0aApmb3Iocz0wO3M8cTsrK3MpaWYocltzXT09PWEpcmV0dXJuIHMKQy5O
+bS5pKHIsYSkKQy5ObS5pKHRoaXMuYixudWxsKQpyZXR1cm4gcX0sClB2OmZ1bmN0aW9uKGEpe3ZhciBz
+LHIscSxwPXRoaXMsbz17fQppZihhPT1udWxsKXJldHVybiBhCmlmKEgubChhKSlyZXR1cm4gYQppZih0
+eXBlb2YgYT09Im51bWJlciIpcmV0dXJuIGEKaWYodHlwZW9mIGE9PSJzdHJpbmciKXJldHVybiBhCmlm
+KGEgaW5zdGFuY2VvZiBQLmlQKXJldHVybiBuZXcgRGF0ZShhLmEpCmlmKHQuZnYuYihhKSl0aHJvdyBI
+LmIoUC5TWSgic3RydWN0dXJlZCBjbG9uZSBvZiBSZWdFeHAiKSkKaWYodC5jOC5iKGEpKXJldHVybiBh
+CmlmKHQudy5iKGEpKXJldHVybiBhCmlmKHQuSS5iKGEpKXJldHVybiBhCnM9dC5kRS5iKGEpfHwhMQpp
+ZihzKXJldHVybiBhCmlmKHQuZi5iKGEpKXtyPXAuVkgoYSkKcz1wLmIKaWYocj49cy5sZW5ndGgpcmV0
+dXJuIEguT0gocyxyKQpxPW8uYT1zW3JdCmlmKHEhPW51bGwpcmV0dXJuIHEKcT17fQpvLmE9cQpDLk5t
+Llk1KHMscixxKQphLksoMCxuZXcgUC5qZyhvLHApKQpyZXR1cm4gby5hfWlmKHQuai5iKGEpKXtyPXAu
+VkgoYSkKbz1wLmIKaWYocj49by5sZW5ndGgpcmV0dXJuIEguT0gobyxyKQpxPW9bcl0KaWYocSE9bnVs
+bClyZXR1cm4gcQpyZXR1cm4gcC5layhhLHIpfWlmKHQuZUguYihhKSl7cj1wLlZIKGEpCnM9cC5iCmlm
+KHI+PXMubGVuZ3RoKXJldHVybiBILk9IKHMscikKcT1vLmI9c1tyXQppZihxIT1udWxsKXJldHVybiBx
+CnE9e30Kby5iPXEKQy5ObS5ZNShzLHIscSkKcC5pbShhLG5ldyBQLlRhKG8scCkpCnJldHVybiBvLmJ9
+dGhyb3cgSC5iKFAuU1koInN0cnVjdHVyZWQgY2xvbmUgb2Ygb3RoZXIgdHlwZSIpKX0sCmVrOmZ1bmN0
+aW9uKGEsYil7dmFyIHMscj1KLlU2KGEpLHE9ci5nQShhKSxwPW5ldyBBcnJheShxKQpDLk5tLlk1KHRo
+aXMuYixiLHApCmZvcihzPTA7czxxOysrcylDLk5tLlk1KHAscyx0aGlzLlB2KHIucShhLHMpKSkKcmV0
+dXJuIHB9fQpQLmpnLnByb3RvdHlwZT17CiQyOmZ1bmN0aW9uKGEsYil7dGhpcy5hLmFbYV09dGhpcy5i
+LlB2KGIpfSwKJFM6MzF9ClAuVGEucHJvdG90eXBlPXsKJDI6ZnVuY3Rpb24oYSxiKXt0aGlzLmEuYlth
+XT10aGlzLmIuUHYoYil9LAokUzoxNn0KUC5CZi5wcm90b3R5cGU9ewppbTpmdW5jdGlvbihhLGIpe3Zh
+ciBzLHIscSxwCnQuYjguYShiKQpmb3Iocz1PYmplY3Qua2V5cyhhKSxyPXMubGVuZ3RoLHE9MDtxPHI7
+KytxKXtwPXNbcV0KYi4kMihwLGFbcF0pfX19ClAuQXMucHJvdG90eXBlPXsKVjpmdW5jdGlvbihhKXt2
+YXIgcwpILmgoYSkKcz0kLmhHKCkuYgppZih0eXBlb2YgYSE9InN0cmluZyIpSC52KEgudEwoYSkpCmlm
+KHMudGVzdChhKSlyZXR1cm4gYQp0aHJvdyBILmIoUC5MMyhhLCJ2YWx1ZSIsIk5vdCBhIHZhbGlkIGNs
+YXNzIHRva2VuIikpfSwKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5EKCkuaygwLCIgIil9LApnbTpm
+dW5jdGlvbihhKXt2YXIgcz10aGlzLkQoKQpyZXR1cm4gUC5yaihzLHMucixILkxoKHMpLmMpfSwKZ2ww
+OmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLkQoKS5hPT09MH0sCmdvcjpmdW5jdGlvbihhKXtyZXR1cm4g
+dGhpcy5EKCkuYSE9PTB9LApnQTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5EKCkuYX0sCnRnOmZ1bmN0
+aW9uKGEsYil7dGhpcy5WKGIpCnJldHVybiB0aGlzLkQoKS50ZygwLGIpfSwKaTpmdW5jdGlvbihhLGIp
+e3ZhciBzCkguaChiKQp0aGlzLlYoYikKcz10aGlzLk8obmV3IFAuR0UoYikpCnJldHVybiBILnk4KHM9
+PW51bGw/ITE6cyl9LApMOmZ1bmN0aW9uKGEsYil7dmFyIHMscgppZih0eXBlb2YgYiE9InN0cmluZyIp
+cmV0dXJuITEKdGhpcy5WKGIpCnM9dGhpcy5EKCkKcj1zLkwoMCxiKQp0aGlzLlgocykKcmV0dXJuIHJ9
+LApGVjpmdW5jdGlvbihhLGIpe3RoaXMuTyhuZXcgUC5ONyh0aGlzLHQuUS5hKGIpKSl9LAplUjpmdW5j
+dGlvbihhLGIpe3ZhciBzPXRoaXMuRCgpCnJldHVybiBILmJLKHMsYixILkxoKHMpLkMoImxmLkUiKSl9
+LApFOmZ1bmN0aW9uKGEsYil7cmV0dXJuIHRoaXMuRCgpLkUoMCxiKX0sClYxOmZ1bmN0aW9uKGEpe3Ro
+aXMuTyhuZXcgUC51USgpKX0sCk86ZnVuY3Rpb24oYSl7dmFyIHMscgp0LmJVLmEoYSkKcz10aGlzLkQo
+KQpyPWEuJDEocykKdGhpcy5YKHMpCnJldHVybiByfX0KUC5HRS5wcm90b3R5cGU9ewokMTpmdW5jdGlv
+bihhKXtyZXR1cm4gdC5DLmEoYSkuaSgwLHRoaXMuYSl9LAokUzozM30KUC5ONy5wcm90b3R5cGU9ewok
+MTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmIscj1ILnQ2KHMpCnJldHVybiB0LkMuYShhKS5GVigwLG5l
+dyBILmxKKHMsci5DKCJxVSgxKSIpLmEodGhpcy5hLmd1TSgpKSxyLkMoImxKPDEscVU+IikpKX0sCiRT
+OjE3fQpQLnVRLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3QuQy5hKGEpCmlmKGEuYT4wKXthLmI9
+YS5jPWEuZD1hLmU9YS5mPW51bGwKYS5hPTAKYS5HWSgpfXJldHVybiBudWxsfSwKJFM6MTd9ClAuaEYu
+cHJvdG90eXBlPXskaWhGOjF9ClAuUEMucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC5Z
+LmEoYSkKcz1mdW5jdGlvbihiLGMsZCl7cmV0dXJuIGZ1bmN0aW9uKCl7cmV0dXJuIGIoYyxkLHRoaXMs
+QXJyYXkucHJvdG90eXBlLnNsaWNlLmFwcGx5KGFyZ3VtZW50cykpfX0oUC5SNCxhLCExKQpQLkRtKHMs
+JC53KCksYSkKcmV0dXJuIHN9LAokUzo0fQpQLm10LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3Jl
+dHVybiBuZXcgdGhpcy5hKGEpfSwKJFM6NH0KUC5RUy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXty
+ZXR1cm4gbmV3IFAucjcoYSl9LAokUzozNX0KUC5ucC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXty
+ZXR1cm4gbmV3IFAuVHooYSx0LmFtKX0sCiRTOjU0fQpQLlV0LnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
+KGEpe3JldHVybiBuZXcgUC5FNChhKX0sCiRTOjM3fQpQLkU0LnByb3RvdHlwZT17CnE6ZnVuY3Rpb24o
+YSxiKXtpZih0eXBlb2YgYiE9InN0cmluZyImJnR5cGVvZiBiIT0ibnVtYmVyIil0aHJvdyBILmIoUC54
+WSgicHJvcGVydHkgaXMgbm90IGEgU3RyaW5nIG9yIG51bSIpKQpyZXR1cm4gUC5kVSh0aGlzLmFbYl0p
+fSwKWTU6ZnVuY3Rpb24oYSxiLGMpe2lmKHR5cGVvZiBiIT0ic3RyaW5nIiYmdHlwZW9mIGIhPSJudW1i
+ZXIiKXRocm93IEguYihQLnhZKCJwcm9wZXJ0eSBpcyBub3QgYSBTdHJpbmcgb3IgbnVtIikpCnRoaXMu
+YVtiXT1QLndZKGMpfSwKRE46ZnVuY3Rpb24oYSxiKXtpZihiPT1udWxsKXJldHVybiExCnJldHVybiBi
+IGluc3RhbmNlb2YgUC5FNCYmdGhpcy5hPT09Yi5hfSwKdzpmdW5jdGlvbihhKXt2YXIgcyxyCnRyeXtz
+PVN0cmluZyh0aGlzLmEpCnJldHVybiBzfWNhdGNoKHIpe0guUnUocikKcz10aGlzLnhiKDApCnJldHVy
+biBzfX0sClY3OmZ1bmN0aW9uKGEsYil7dmFyIHMscj10aGlzLmEKaWYoYj09bnVsbClzPW51bGwKZWxz
+ZXtzPUgudDYoYikKcz1QLkNIKG5ldyBILmxKKGIscy5DKCJAKDEpIikuYShQLmlHKCkpLHMuQygibEo8
+MSxAPiIpKSwhMCx0LnopfXJldHVybiBQLmRVKHJbYV0uYXBwbHkocixzKSl9LApnaU86ZnVuY3Rpb24o
+YSl7cmV0dXJuIDB9fQpQLnI3LnByb3RvdHlwZT17fQpQLlR6LnByb3RvdHlwZT17CmNQOmZ1bmN0aW9u
+KGEpe3ZhciBzPXRoaXMscj1hPDB8fGE+PXMuZ0EocykKaWYocil0aHJvdyBILmIoUC5URShhLDAscy5n
+QShzKSxudWxsLG51bGwpKX0sCnE6ZnVuY3Rpb24oYSxiKXtpZihILm9rKGIpKXRoaXMuY1AoYikKcmV0
+dXJuIHRoaXMuJHRpLmMuYSh0aGlzLlVyKDAsYikpfSwKWTU6ZnVuY3Rpb24oYSxiLGMpe3RoaXMuY1Ao
+YikKdGhpcy5lNCgwLGIsYyl9LApnQTpmdW5jdGlvbihhKXt2YXIgcz10aGlzLmEubGVuZ3RoCmlmKHR5
+cGVvZiBzPT09Im51bWJlciImJnM+Pj4wPT09cylyZXR1cm4gcwp0aHJvdyBILmIoUC5QVigiQmFkIEpz
+QXJyYXkgbGVuZ3RoIikpfSwKJGliUToxLAokaWNYOjEsCiRpek06MX0KUC5jby5wcm90b3R5cGU9e30K
+UC5uZC5wcm90b3R5cGU9eyRpbmQ6MX0KUC5LZS5wcm90b3R5cGU9ewpEOmZ1bmN0aW9uKCl7dmFyIHMs
+cixxLHAsbz10aGlzLmEuZ2V0QXR0cmlidXRlKCJjbGFzcyIpLG49UC5Mcyh0Lk4pCmlmKG89PW51bGwp
+cmV0dXJuIG4KZm9yKHM9by5zcGxpdCgiICIpLHI9cy5sZW5ndGgscT0wO3E8cjsrK3Epe3A9Si5UMChz
+W3FdKQppZihwLmxlbmd0aCE9PTApbi5pKDAscCl9cmV0dXJuIG59LApYOmZ1bmN0aW9uKGEpe3RoaXMu
+YS5zZXRBdHRyaWJ1dGUoImNsYXNzIixhLmsoMCwiICIpKX19ClAuaGkucHJvdG90eXBlPXsKZ246ZnVu
+Y3Rpb24oYSl7cmV0dXJuIG5ldyBQLktlKGEpfSwKc2hmOmZ1bmN0aW9uKGEsYil7dGhpcy5ZQyhhLGIp
+fSwKcjY6ZnVuY3Rpb24oYSxiLGMsZCl7dmFyIHMscixxLHAsbyxuCmlmKGQ9PW51bGwpe3M9SC5WTShb
+XSx0LnYpCmQ9bmV3IFcudkQocykKQy5ObS5pKHMsVy5UdyhudWxsKSkKQy5ObS5pKHMsVy5CbCgpKQpD
+Lk5tLmkocyxuZXcgVy5PdygpKX1jPW5ldyBXLktvKGQpCnI9JzxzdmcgdmVyc2lvbj0iMS4xIj4nK0gu
+RWooYikrIjwvc3ZnPiIKcz1kb2N1bWVudApxPXMuYm9keQpxLnRvU3RyaW5nCnA9Qy5SWS5BSChxLHIs
+YykKbz1zLmNyZWF0ZURvY3VtZW50RnJhZ21lbnQoKQpwLnRvU3RyaW5nCnM9bmV3IFcuZTcocCkKbj1z
+LmdyOChzKQpmb3IoO3M9bi5maXJzdENoaWxkLHMhPW51bGw7KW8uYXBwZW5kQ2hpbGQocykKcmV0dXJu
+IG99LApuejpmdW5jdGlvbihhLGIsYyxkLGUpe3Rocm93IEguYihQLkw0KCJDYW5ub3QgaW52b2tlIGlu
+c2VydEFkamFjZW50SHRtbCBvbiBTVkcuIikpfSwKZ1ZsOmZ1bmN0aW9uKGEpe3JldHVybiBuZXcgVy5l
+dShhLCJjbGljayIsITEsdC5rKX0sCiRpaGk6MX0KTS5INy5wcm90b3R5cGU9ewp3OmZ1bmN0aW9uKGEp
+e3JldHVybiB0aGlzLmJ9fQpVLkxMLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJuIFAuRUYo
+WyJub2RlSWQiLHRoaXMuYiwia2luZCIsdGhpcy5hLmFdLHQuWCx0Ll8pfX0KVS5NRC5wcm90b3R5cGU9
+ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdC5mRS5hKGEpLmE9PT10aGlzLmEucSgwLCJraW5kIil9LAok
+UzozOH0KVS5kMi5wcm90b3R5cGU9ewpMdDpmdW5jdGlvbigpe3ZhciBzLHIscSxwLG89dGhpcyxuPXQu
+WCxtPXQuXyxsPVAuRmwobixtKSxrPW8uYQppZihrIT1udWxsKXtzPUguVk0oW10sdC5HKQpmb3Iocj1r
+Lmxlbmd0aCxxPTA7cTxrLmxlbmd0aDtrLmxlbmd0aD09PXJ8fCgwLEgubGspKGspLCsrcSl7cD1rW3Fd
+CnMucHVzaChQLkVGKFsiZGVzY3JpcHRpb24iLHAuYSwiaHJlZiIscC5iXSxuLG0pKX1sLlk1KDAsImVk
+aXRzIixzKX1sLlk1KDAsImV4cGxhbmF0aW9uIixvLmIpCmwuWTUoMCwibGluZSIsby5jKQpsLlk1KDAs
+ImRpc3BsYXlQYXRoIixvLmQpCmwuWTUoMCwidXJpUGF0aCIsby5lKQpuPW8uZgppZihuIT1udWxsKXtt
+PUguVk0oW10sdC5HKQpmb3Ioaz1uLmxlbmd0aCxxPTA7cTxuLmxlbmd0aDtuLmxlbmd0aD09PWt8fCgw
+LEgubGspKG4pLCsrcSltLnB1c2gobltxXS5MdCgpKQpsLlk1KDAsInRyYWNlcyIsbSl9cmV0dXJuIGx9
+fQpVLlNlLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJuIFAuRUYoWyJkZXNjcmlwdGlvbiIs
+dGhpcy5hLCJocmVmIix0aGlzLmJdLHQuWCx0Ll8pfX0KVS5NbC5wcm90b3R5cGU9ewpMdDpmdW5jdGlv
+bigpe3JldHVybiBQLkVGKFsiaHJlZiIsdGhpcy5hLCJsaW5lIix0aGlzLmIsInBhdGgiLHRoaXMuY10s
+dC5YLHQuXyl9fQpVLnlELnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscixxLHA9SC5WTShb
+XSx0LkcpCmZvcihzPXRoaXMuYixyPXMubGVuZ3RoLHE9MDtxPHMubGVuZ3RoO3MubGVuZ3RoPT09cnx8
+KDAsSC5saykocyksKytxKXAucHVzaChzW3FdLkx0KCkpCnJldHVybiBQLkVGKFsiZGVzY3JpcHRpb24i
+LHRoaXMuYSwiZW50cmllcyIscF0sdC5YLHQuXyl9fQpVLndiLnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9u
+KCl7dmFyIHMscixxLHA9dGhpcyxvPVAuRmwodC5YLHQuXykKby5ZNSgwLCJkZXNjcmlwdGlvbiIscC5h
+KQpzPXAuYgppZihzIT1udWxsKW8uWTUoMCwiZnVuY3Rpb24iLHMpCnM9cC5jCmlmKHMhPW51bGwpby5Z
+NSgwLCJsaW5rIixzLkx0KCkpCnM9cC5kCmlmKHMubGVuZ3RoIT09MCl7cj1ILnQ2KHMpCnE9ci5DKCJs
+SjwxLFowPHFVKixNaCo+Kj4iKQpvLlk1KDAsImhpbnRBY3Rpb25zIixQLlkxKG5ldyBILmxKKHMsci5D
+KCJaMDxxVSosTWgqPiooMSkiKS5hKG5ldyBVLmIwKCkpLHEpLCEwLHEuQygiYUwuRSIpKSl9cmV0dXJu
+IG99fQpVLmFOLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiBVLm56KHQudC5hKGEpKX0s
+CiRTOjM5fQpVLmIwLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0LmFYLmEoYSkuTHQo
+KX0sCiRTOjQwfQpCLmo4LnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7cmV0dXJuIFAuRUYoWyJsaW5l
+Iix0aGlzLmEsImV4cGxhbmF0aW9uIix0aGlzLmIsIm9mZnNldCIsdGhpcy5jXSx0LlgsdC5fKX19CkIu
+cXAucHJvdG90eXBlPXsKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbSxsPXRoaXMsaz10Llgs
+aj1QLkZsKGssdC5kcCkKZm9yKHM9bC5kLHM9cy5nUHUocykscz1zLmdtKHMpLHI9dC5fLHE9dC5HO3Mu
+RigpOyl7cD1zLmdsKCkKbz1wLmEKbj1ILlZNKFtdLHEpCmZvcihwPUouSVQocC5iKTtwLkYoKTspe209
+cC5nbCgpCm4ucHVzaChQLkVGKFsibGluZSIsbS5hLCJleHBsYW5hdGlvbiIsbS5iLCJvZmZzZXQiLG0u
+Y10sayxyKSl9ai5ZNSgwLG8sbil9cmV0dXJuIFAuRUYoWyJyZWdpb25zIixsLmEsIm5hdmlnYXRpb25D
+b250ZW50IixsLmIsInNvdXJjZUNvZGUiLGwuYywiZWRpdHMiLGpdLGsscil9fQpULm1RLnByb3RvdHlw
+ZT17fQpMLmUucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0KdC5hTC5h
+KGEpCnM9d2luZG93LmxvY2F0aW9uLnBhdGhuYW1lCnI9TC5HNih3aW5kb3cubG9jYXRpb24uaHJlZikK
+cT1MLmFLKHdpbmRvdy5sb2NhdGlvbi5ocmVmKQpMLkdlKCkKaWYocyE9PSIvIiYmcyE9PUouVDAoZG9j
+dW1lbnQucXVlcnlTZWxlY3RvcigiLnJvb3QiKS50ZXh0Q29udGVudCkpTC5HNyhzLHIscSwhMCxuZXcg
+TC5WVyhzLHIscSkpCnA9ZG9jdW1lbnQKbz1KLnFGKHAucXVlcnlTZWxlY3RvcigiLmFwcGx5LW1pZ3Jh
+dGlvbiIpKQpuPW8uJHRpCm09bi5DKCJ+KDEpPyIpLmEobmV3IEwub1ooKSkKdC5aLmEobnVsbCkKVy5K
+RShvLmEsby5iLG0sITEsbi5jKQpuPUoucUYocC5xdWVyeVNlbGVjdG9yKCIucmVydW4tbWlncmF0aW9u
+IikpCm09bi4kdGkKVy5KRShuLmEsbi5iLG0uQygifigxKT8iKS5hKG5ldyBMLkhpKCkpLCExLG0uYykK
+bT1KLnFGKHAucXVlcnlTZWxlY3RvcigiLnJlcG9ydC1wcm9ibGVtIikpCm49bS4kdGkKVy5KRShtLmEs
+bS5iLG4uQygifigxKT8iKS5hKG5ldyBMLkJUKCkpLCExLG4uYykKcD1KLnFGKHAucXVlcnlTZWxlY3Rv
+cigiLnBvcHVwLXBhbmUgLmNsb3NlIikpCm49cC4kdGkKVy5KRShwLmEscC5iLG4uQygifigxKT8iKS5h
+KG5ldyBMLlBZKCkpLCExLG4uYykKbj1KLnFGKCQuYzAoKSkKcD1uLiR0aQpXLkpFKG4uYSxuLmIscC5D
+KCJ+KDEpPyIpLmEobmV3IEwudTgoKSksITEscC5jKX0sCiRTOjE4fQpMLlZXLnByb3RvdHlwZT17CiQw
+OmZ1bmN0aW9uKCl7TC5Gcih0aGlzLmEsdGhpcy5iLHRoaXMuYyl9LAokUzoyfQpMLm9aLnByb3RvdHlw
+ZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzLHIscSxwLG8KdC5PLmEoYSkKaWYoSC5vVChDLm9sLnVzKHdp
+bmRvdywiVGhpcyB3aWxsIGFwcGx5IHRoZSBjaGFuZ2VzIHlvdSd2ZSBwcmV2aWV3ZWQgdG8geW91ciB3
+b3JraW5nIGRpcmVjdG9yeS4gSXQgaXMgcmVjb21tZW5kZWQgeW91IGNvbW1pdCBhbnkgY2hhbmdlcyB5
+b3UgbWFkZSBiZWZvcmUgZG9pbmcgdGhpcy4iKSkpe3M9SC5WTShbXSx0LkcpCmZvcihyPSQuSVIscT1y
+Lmxlbmd0aCxwPTA7cDxyLmxlbmd0aDtyLmxlbmd0aD09PXF8fCgwLEgubGspKHIpLCsrcClzLnB1c2go
+cltwXS5MdCgpKQpzPUwudHkoIi9hcHBseS1taWdyYXRpb24iLFAuRUYoWyJuYXZpZ2F0aW9uVHJlZSIs
+c10sdC5YLHQuZHApKS5XNyhuZXcgTC5qcigpLHQuUCkKbz1uZXcgTC5xbCgpCnQuYjcuYShudWxsKQpy
+PXMuJHRpCnE9JC5YMwppZihxIT09Qy5OVSlvPVAuVkgobyxxKQpzLnhmKG5ldyBQLkZlKG5ldyBQLnZz
+KHEsciksMixudWxsLG8sci5DKCJAPDE+IikuS3Eoci5jKS5DKCJGZTwxLDI+IikpKX19LAokUzoxfQpM
+LmpyLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQudC5hKGEpCnM9ZG9jdW1lbnQuYm9k
+eQpzLmNsYXNzTGlzdC5yZW1vdmUoInByb3Bvc2VkIikKcy5jbGFzc0xpc3QuYWRkKCJhcHBsaWVkIil9
+LAokUzo0M30KTC5xbC5wcm90b3R5cGU9ewokMjpmdW5jdGlvbihhLGIpe0wuQzIoIkNvdWxkIG5vdCBh
+cHBseSBtaWdyYXRpb24iLGEsYil9LAokQzoiJDIiLAokUjoyLAokUzoxNn0KTC5IaS5wcm90b3R5cGU9
+ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy54bih0Lk8uYShhKSl9LAp4bjpmdW5jdGlvbihhKXt2
+YXIgcz0wLHI9UC5GWCh0LlApLHE9MSxwLG89W10sbixtLGwsayxqCnZhciAkYXN5bmMkJDE9UC5seihm
+dW5jdGlvbihiLGMpe2lmKGI9PT0xKXtwPWMKcz1xfXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nhc2UgMDpx
+PTMKZG9jdW1lbnQuYm9keS5jbGFzc0xpc3QuYWRkKCJyZXJ1bm5pbmciKQpzPTYKcmV0dXJuIFAualEo
+TC50eSgiL3JlcnVuLW1pZ3JhdGlvbiIsbnVsbCksJGFzeW5jJCQxKQpjYXNlIDY6bj1jCmlmKEgub1Qo
+SC55OChKLng5KG4sInN1Y2Nlc3MiKSkpKXdpbmRvdy5sb2NhdGlvbi5yZWxvYWQoKQplbHNlIEwuSzAo
+dC5lRS5hKEoueDkobiwiZXJyb3JzIikpKQpvLnB1c2goNSkKcz00CmJyZWFrCmNhc2UgMzpxPTIKaj1w
+Cm09SC5SdShqKQpsPUgudHMoaikKTC5DMigiRmFpbGVkIHRvIHJlcnVuIG1pZ3JhdGlvbiIsbSxsKQpv
+LnB1c2goNSkKcz00CmJyZWFrCmNhc2UgMjpvPVsxXQpjYXNlIDQ6cT0xCmRvY3VtZW50LmJvZHkuY2xh
+c3NMaXN0LnJlbW92ZSgicmVydW5uaW5nIikKcz1vLnBvcCgpCmJyZWFrCmNhc2UgNTpyZXR1cm4gUC55
+QyhudWxsLHIpCmNhc2UgMTpyZXR1cm4gUC5mMyhwLHIpfX0pCnJldHVybiBQLkRJKCRhc3luYyQkMSxy
+KX0sCiRTOjE5fQpMLkJULnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQuTy5hKGEpCnM9
+dC5YCkMub2wuUG8od2luZG93LFAuWGQoImh0dHBzIiwiZ2l0aHViLmNvbSIsImRhcnQtbGFuZy9zZGsv
+aXNzdWVzL25ldyIsUC5FRihbInRpdGxlIiwiQ3VzdG9tZXItcmVwb3J0ZWQgaXNzdWUgd2l0aCBOTkJE
+IG1pZ3JhdGlvbiB0b29sIiwibGFiZWxzIix1LmQsImJvZHkiLCIjIyMjIFN0ZXBzIHRvIHJlcHJvZHVj
+ZVxuXG4jIyMjIFdoYXQgZGlkIHlvdSBleHBlY3QgdG8gaGFwcGVuP1xuXG4jIyMjIFdoYXQgYWN0dWFs
+bHkgaGFwcGVuZWQ/XG5cbl9TY3JlZW5zaG90cyBhcmUgYXBwcmVjaWF0ZWRfXG5cbioqRGFydCBTREsg
+dmVyc2lvbioqOiAiK0guRWooZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInNkay12ZXJzaW9uIikudGV4
+dENvbnRlbnQpKyJcblxuVGhhbmtzIGZvciBmaWxpbmchXG4iXSxzLHMpKS5nbkQoKSwicmVwb3J0LXBy
+b2JsZW0iKX0sCiRTOjF9CkwuUFkucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMKdC5PLmEo
+YSkKcz1kb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIucG9wdXAtcGFuZSIpLnN0eWxlCnMuZGlzcGxheT0i
+bm9uZSIKcmV0dXJuIm5vbmUifSwKJFM6NDV9CkwudTgucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7
+dmFyIHMscixxLHAKdC5PLmEoYSkKcz0kLkQ5KCkuaW5uZXJUZXh0CnI9dC5nLmEoZG9jdW1lbnQucXVl
+cnlTZWxlY3RvcignLm5hdi1wYW5lbCBbZGF0YS1uYW1lKj0iJytILkVqKHMpKyciXScpLnBhcmVudE5v
+ZGUpCnE9ci5xdWVyeVNlbGVjdG9yKCIuc3RhdHVzLWljb24iKQpwPUwubUgoJC5JUixzKQppZihwIGlu
+c3RhbmNlb2YgTC5jRCl7TC5PdChwKQpMLnhuKHEscCkKTC5BUihyLHApfX0sCiRTOjF9CkwuTC5wcm90
+b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcyxyLHEKdC5hTC5hKGEpCnM9d2luZG93LmxvY2F0aW9u
+LnBhdGhuYW1lCnI9TC5HNih3aW5kb3cubG9jYXRpb24uaHJlZikKcT1MLmFLKHdpbmRvdy5sb2NhdGlv
+bi5ocmVmKQppZihzLmxlbmd0aD4xKUwuRzcocyxyLHEsITEsbnVsbCkKZWxzZXtMLkJFKHMsQi53Uigp
+LCEwKQpMLkJYKCImbmJzcDsiLG51bGwpfX0sCiRTOjE4fQpMLld4LnByb3RvdHlwZT17CiQxOmZ1bmN0
+aW9uKGEpe3ZhciBzLHIscSxwPSJjb2xsYXBzZWQiCnQuTy5hKGEpCnM9dGhpcy5hCnI9Si5ZRShzKQpx
+PXRoaXMuYgppZighci5nbihzKS50ZygwLHApKXtyLmduKHMpLmkoMCxwKQpKLmRSKHEpLmkoMCxwKX1l
+bHNle3IuZ24ocykuTCgwLHApCkouZFIocSkuTCgwLHApfX0sCiRTOjF9CkwuQU8ucHJvdG90eXBlPXsK
+JDE6ZnVuY3Rpb24oYSl7dmFyIHM9Si5xRih0LmcuYShhKSkscj1zLiR0aSxxPXIuQygifigxKT8iKS5h
+KG5ldyBMLmROKHRoaXMuYSkpCnQuWi5hKG51bGwpClcuSkUocy5hLHMuYixxLCExLHIuYyl9LAokUzoz
+fQpMLmROLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3ZhciBzCnQuTy5hKGEpCnM9ZG9jdW1lbnQu
+cXVlcnlTZWxlY3RvcigidGFibGVbZGF0YS1wYXRoXSIpCnMudG9TdHJpbmcKTC50MihhLHRoaXMuYSxz
+LmdldEF0dHJpYnV0ZSgiZGF0YS0iK25ldyBXLlN5KG5ldyBXLmk3KHMpKS5QKCJwYXRoIikpKX0sCiRT
+OjF9CkwuSG8ucHJvdG90eXBlPXsKJDE6ZnVuY3Rpb24oYSl7dmFyIHMscixxCnQuZy5hKGEpCnM9Si5x
+RihhKQpyPXMuJHRpCnE9ci5DKCJ+KDEpPyIpLmEobmV3IEwueHooYSx0aGlzLmEpKQp0LlouYShudWxs
+KQpXLkpFKHMuYSxzLmIscSwhMSxyLmMpfSwKJFM6M30KTC54ei5wcm90b3R5cGU9ewokMTpmdW5jdGlv
+bihhKXt2YXIgcwp0Lk8uYShhKQpzPXRoaXMuYQpMLmhYKHRoaXMuYixQLlFBKHMuZ2V0QXR0cmlidXRl
+KCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcocykpLlAoIm9mZnNldCIpKSxudWxsKSxQLlFBKHMuZ2V0
+QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcocykpLlAoImxpbmUiKSksbnVsbCkpfSwK
+JFM6MX0KTC5JQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2YXIgcz1KLnFGKHQuZy5hKGEpKSxy
+PXMuJHRpCnIuQygifigxKT8iKS5hKEwuaVMoKSkKdC5aLmEobnVsbCkKVy5KRShzLmEscy5iLEwuaVMo
+KSwhMSxyLmMpfSwKJFM6M30KTC5mQy5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt0LmVRLmEoYSkK
+dGhpcy5hLmFNKDAsdGhpcy5iKX0sCiRTOjQ3fQpMLm5ULnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7
+TC5Gcih0aGlzLmEsdGhpcy5iLHRoaXMuYyl9LAokUzoyfQpMLk5ZLnByb3RvdHlwZT17CiQwOmZ1bmN0
+aW9uKCl7TC5Gcih0aGlzLmEsbnVsbCxudWxsKX0sCiRTOjJ9CkwudWUucHJvdG90eXBlPXsKJDE6ZnVu
+Y3Rpb24oYSl7dC5hdy5hKGEpCnJldHVybiBILkVqKGEucSgwLCJzZXZlcml0eSIpKSsiIC0gIitILkVq
+KGEucSgwLCJtZXNzYWdlIikpKyIgYXQgIitILkVqKGEucSgwLCJsb2NhdGlvbiIpKSsiIC0gKCIrSC5F
+aihhLnEoMCwiY29kZSIpKSsiKSJ9LAokUzo0OH0KTC5lWC5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihh
+KXt0LmcuYShhKQokLnpCKCkudG9TdHJpbmcKdC5kSC5hKCQub3coKS5xKDAsImhsanMiKSkuVjcoImhp
+Z2hsaWdodEJsb2NrIixbYV0pfSwKJFM6M30KTC5FRS5wcm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXt2
+YXIgcyxyCnQuTy5hKGEpLnByZXZlbnREZWZhdWx0KCkKcz10aGlzLmEKcj10aGlzLmIKTC5hZih3aW5k
+b3cubG9jYXRpb24ucGF0aG5hbWUscyxyLCEwLG5ldyBMLlFMKHMscikpCkwuaFgodGhpcy5jLHMscil9
+LAokUzoxfQpMLlFMLnByb3RvdHlwZT17CiQwOmZ1bmN0aW9uKCl7TC5Gcih3aW5kb3cubG9jYXRpb24u
+cGF0aG5hbWUsdGhpcy5hLHRoaXMuYil9LAokUzoyfQpMLlZTLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9u
+KGEpe3ZhciBzLHI9InNlbGVjdGVkLWZpbGUiCnQuZy5hKGEpCmEudG9TdHJpbmcKcz1KLllFKGEpCmlm
+KGEuZ2V0QXR0cmlidXRlKCJkYXRhLSIrbmV3IFcuU3kobmV3IFcuaTcoYSkpLlAoIm5hbWUiKSk9PT10
+aGlzLmEuYSlzLmduKGEpLmkoMCxyKQplbHNlIHMuZ24oYSkuTCgwLHIpfSwKJFM6M30KTC5URC5wcm90
+b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gTC50Mih0Lk8uYShhKSwhMCxudWxsKX0sCiRTOjIw
+fQpMLm0yLnByb3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlJJKHQuTy5hKGEpKX0s
+ClJJOmZ1bmN0aW9uKGEpe3ZhciBzPTAscj1QLkZYKHQuUCkscT0xLHAsbz1bXSxuPXRoaXMsbSxsLGss
+aixpLGgsZyxmCnZhciAkYXN5bmMkJDE9UC5seihmdW5jdGlvbihiLGMpe2lmKGI9PT0xKXtwPWMKcz1x
+fXdoaWxlKHRydWUpc3dpdGNoKHMpe2Nhc2UgMDpxPTMKaT1kb2N1bWVudAptPUMuQ0QuelEoaS5xdWVy
+eVNlbGVjdG9yKCIuY29udGVudCIpLnNjcm9sbFRvcCkKaD10LlgKcz02CnJldHVybiBQLmpRKEwudHko
+TC5RNCgiL2FwcGx5LWhpbnQiLFAuRmwoaCxoKSksbi5hLkx0KCkpLCRhc3luYyQkMSkKY2FzZSA2Omg9
+bi5iCmw9TC5VcyhoLmEpCnM9NwpyZXR1cm4gUC5qUShMLkc3KGwsbnVsbCxoLmIsITEsbnVsbCksJGFz
+eW5jJCQxKQpjYXNlIDc6aS5ib2R5LmNsYXNzTGlzdC5hZGQoIm5lZWRzLXJlcnVuIikKaT1pLnF1ZXJ5
+U2VsZWN0b3IoIi5jb250ZW50IikKaS50b1N0cmluZwppLnNjcm9sbFRvcD1KLlZ1KG0pCnE9MQpzPTUK
+YnJlYWsKY2FzZSAzOnE9MgpmPXAKaz1ILlJ1KGYpCmo9SC50cyhmKQpMLkMyKCJDb3VsZCBub3QgYXBw
+bHkgaGludCIsayxqKQpzPTUKYnJlYWsKY2FzZSAyOnM9MQpicmVhawpjYXNlIDU6cmV0dXJuIFAueUMo
+bnVsbCxyKQpjYXNlIDE6cmV0dXJuIFAuZjMocCxyKX19KQpyZXR1cm4gUC5ESSgkYXN5bmMkJDEscil9
+LAokUzoxOX0KTC5YQS5wcm90b3R5cGU9ewpFYjpmdW5jdGlvbihhLGIsYyl7cmV0dXJuITB9LAppMDpm
+dW5jdGlvbihhKXtyZXR1cm4hMH0sCiRpa0Y6MX0KTC52dC5wcm90b3R5cGU9ewpnZDY6ZnVuY3Rpb24o
+KXt2YXIgcyxyLHEscCxvLG4sbSxsPXRoaXMuZAppZihsLmxlbmd0aD09PTApcmV0dXJuIEMuY3cKcz1D
+Lk5tLmd0SChsKS5nZDYoKQpmb3Iocj1sLmxlbmd0aCxxPSEwLHA9ITAsbz0wO288bC5sZW5ndGg7bC5s
+ZW5ndGg9PT1yfHwoMCxILmxrKShsKSwrK28pe249bFtvXS5nZDYoKQppZihuIT1zKXM9bnVsbAptPW4h
+PT1DLmN3CmlmKG0mJm4hPT1DLldEKXE9ITEKaWYobSYmbiE9PUMuWGopcD0hMX1pZihzIT1udWxsKXJl
+dHVybiBzCmlmKHEpcmV0dXJuIEMuV0QKaWYocClyZXR1cm4gQy5YagpyZXR1cm4gQy5kY30sCkxWOmZ1
+bmN0aW9uKCl7dmFyIHMscixxPXRoaXMuZAppZihxIT1udWxsKWZvcihzPXEubGVuZ3RoLHI9MDtyPHM7
+KytyKXFbcl0uYj10aGlzfSwKTHQ6ZnVuY3Rpb24oKXt2YXIgcyxyPVAuRmwodC5YLHQuXykKci5ZNSgw
+LCJ0eXBlIiwiZGlyZWN0b3J5IikKci5ZNSgwLCJuYW1lIix0aGlzLmEpCnIuWTUoMCwic3VidHJlZSIs
+TC5WRCh0aGlzLmQpKQpzPXRoaXMuYwppZihzIT1udWxsKXIuWTUoMCwicGF0aCIscykKcmV0dXJuIHJ9
+fQpMLmNELnByb3RvdHlwZT17Ckx0OmZ1bmN0aW9uKCl7dmFyIHMscj10aGlzLHE9UC5GbCh0LlgsdC5f
+KQpxLlk1KDAsInR5cGUiLCJmaWxlIikKcS5ZNSgwLCJuYW1lIixyLmEpCnM9ci5jCmlmKHMhPW51bGwp
+cS5ZNSgwLCJwYXRoIixzKQpzPXIuZAppZihzIT1udWxsKXEuWTUoMCwiaHJlZiIscykKcz1yLmUKaWYo
+cyE9bnVsbClxLlk1KDAsImVkaXRDb3VudCIscykKcz1yLmYKaWYocyE9bnVsbClxLlk1KDAsIndhc0V4
+cGxpY2l0bHlPcHRlZE91dCIscykKcz1yLnIKaWYocyE9bnVsbClxLlk1KDAsIm1pZ3JhdGlvblN0YXR1
+cyIscy5hKQpyZXR1cm4gcX0sCmdkNjpmdW5jdGlvbigpe3JldHVybiB0aGlzLnJ9fQpMLkQ4LnByb3Rv
+dHlwZT17fQpMLk85LnByb3RvdHlwZT17Cnc6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuYn19CkwuR2Iu
+cHJvdG90eXBlPXsKdzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5ifX0KTS5sSS5wcm90b3R5cGU9ewpn
+bDpmdW5jdGlvbigpe3ZhciBzPUQuYWIoKQpyZXR1cm4gc30sCldPOmZ1bmN0aW9uKGEsYil7dmFyIHMs
+cixxPXQuZDQKTS5ZRigiYWJzb2x1dGUiLEguVk0oW2IsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsLG51
+bGxdLHEpKQpzPXRoaXMuYQpzPXMuWXIoYik+MCYmIXMuaEsoYikKaWYocylyZXR1cm4gYgpyPUguVk0o
+W3RoaXMuZ2woKSxiLG51bGwsbnVsbCxudWxsLG51bGwsbnVsbCxudWxsXSxxKQpNLllGKCJqb2luIixy
+KQpyZXR1cm4gdGhpcy5JUChuZXcgSC51NihyLHQuZUopKX0sCnpmOmZ1bmN0aW9uKGEpe3ZhciBzLHIs
+cT1YLkNMKGEsdGhpcy5hKQpxLkl4KCkKcz1xLmQKcj1zLmxlbmd0aAppZihyPT09MCl7cz1xLmIKcmV0
+dXJuIHM9PW51bGw/Ii4iOnN9aWYocj09PTEpe3M9cS5iCnJldHVybiBzPT1udWxsPyIuIjpzfWlmKDA+
+PXIpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKQpzPXEuZQppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5P
+SChzLC0xKQpzLnBvcCgpCnEuSXgoKQpyZXR1cm4gcS53KDApfSwKSVA6ZnVuY3Rpb24oYSl7dmFyIHMs
+cixxLHAsbyxuLG0sbCxrLGoKdC5RLmEoYSkKZm9yKHM9YS4kdGkscj1zLkMoImEyKGNYLkUpIikuYShu
+ZXcgTS5xNygpKSxxPWEuZ20oYSkscz1uZXcgSC5TTyhxLHIscy5DKCJTTzxjWC5FPiIpKSxyPXRoaXMu
+YSxwPSExLG89ITEsbj0iIjtzLkYoKTspe209cS5nbCgpCmlmKHIuaEsobSkmJm8pe2w9WC5DTChtLHIp
+Cms9bi5jaGFyQ29kZUF0KDApPT0wP246bgpuPUMueEIuTmooaywwLHIuU3AoaywhMCkpCmwuYj1uCmlm
+KHIuZHMobikpQy5ObS5ZNShsLmUsMCxyLmdtSSgpKQpuPWwudygwKX1lbHNlIGlmKHIuWXIobSk+MCl7
+bz0hci5oSyhtKQpuPUguRWoobSl9ZWxzZXtqPW0ubGVuZ3RoCmlmKGohPT0wKXtpZigwPj1qKXJldHVy
+biBILk9IKG0sMCkKaj1yLlVkKG1bMF0pfWVsc2Ugaj0hMQppZighailpZihwKW4rPXIuZ21JKCkKbis9
+bX1wPXIuZHMobSl9cmV0dXJuIG4uY2hhckNvZGVBdCgwKT09MD9uOm59LApvNTpmdW5jdGlvbihhKXt2
+YXIgcwppZighdGhpcy55MyhhKSlyZXR1cm4gYQpzPVguQ0woYSx0aGlzLmEpCnMuclIoKQpyZXR1cm4g
+cy53KDApfSwKeTM6ZnVuY3Rpb24oYSl7dmFyIHMscixxLHAsbyxuLG0sbCxrLGoKYS50b1N0cmluZwpz
+PXRoaXMuYQpyPXMuWXIoYSkKaWYociE9PTApe2lmKHM9PT0kLktrKCkpZm9yKHE9MDtxPHI7KytxKWlm
+KEMueEIuVyhhLHEpPT09NDcpcmV0dXJuITAKcD1yCm89NDd9ZWxzZXtwPTAKbz1udWxsfWZvcihuPW5l
+dyBILnFqKGEpLmEsbT1uLmxlbmd0aCxxPXAsbD1udWxsO3E8bTsrK3EsbD1vLG89ayl7az1DLnhCLk8y
+KG4scSkKaWYocy5yNChrKSl7aWYocz09PSQuS2soKSYmaz09PTQ3KXJldHVybiEwCmlmKG8hPW51bGwm
+JnMucjQobykpcmV0dXJuITAKaWYobz09PTQ2KWo9bD09bnVsbHx8bD09PTQ2fHxzLnI0KGwpCmVsc2Ug
+aj0hMQppZihqKXJldHVybiEwfX1pZihvPT1udWxsKXJldHVybiEwCmlmKHMucjQobykpcmV0dXJuITAK
+aWYobz09PTQ2KXM9bD09bnVsbHx8cy5yNChsKXx8bD09PTQ2CmVsc2Ugcz0hMQppZihzKXJldHVybiEw
+CnJldHVybiExfSwKSFA6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHEscCxvLG4sbSxsPXRoaXMsaz0nVW5h
+YmxlIHRvIGZpbmQgYSBwYXRoIHRvICInCmI9bC5XTygwLGIpCnM9bC5hCmlmKHMuWXIoYik8PTAmJnMu
+WXIoYSk+MClyZXR1cm4gbC5vNShhKQppZihzLllyKGEpPD0wfHxzLmhLKGEpKWE9bC5XTygwLGEpCmlm
+KHMuWXIoYSk8PTAmJnMuWXIoYik+MCl0aHJvdyBILmIoWC5JNyhrK0guRWooYSkrJyIgZnJvbSAiJytI
+LkVqKGIpKyciLicpKQpyPVguQ0woYixzKQpyLnJSKCkKcT1YLkNMKGEscykKcS5yUigpCnA9ci5kCm89
+cC5sZW5ndGgKaWYobyE9PTApe2lmKDA+PW8pcmV0dXJuIEguT0gocCwwKQpwPUouUk0ocFswXSwiLiIp
+fWVsc2UgcD0hMQppZihwKXJldHVybiBxLncoMCkKcD1yLmIKbz1xLmIKaWYocCE9bylwPXA9PW51bGx8
+fG89PW51bGx8fCFzLk5jKHAsbykKZWxzZSBwPSExCmlmKHApcmV0dXJuIHEudygwKQp3aGlsZSghMCl7
+cD1yLmQKbz1wLmxlbmd0aAppZihvIT09MCl7bj1xLmQKbT1uLmxlbmd0aAppZihtIT09MCl7aWYoMD49
+bylyZXR1cm4gSC5PSChwLDApCnA9cFswXQppZigwPj1tKXJldHVybiBILk9IKG4sMCkKbj1zLk5jKHAs
+blswXSkKcD1ufWVsc2UgcD0hMX1lbHNlIHA9ITEKaWYoIXApYnJlYWsKQy5ObS5XNChyLmQsMCkKQy5O
+bS5XNChyLmUsMSkKQy5ObS5XNChxLmQsMCkKQy5ObS5XNChxLmUsMSl9cD1yLmQKbz1wLmxlbmd0aApp
+ZihvIT09MCl7aWYoMD49bylyZXR1cm4gSC5PSChwLDApCnA9Si5STShwWzBdLCIuLiIpfWVsc2UgcD0h
+MQppZihwKXRocm93IEguYihYLkk3KGsrSC5FaihhKSsnIiBmcm9tICInK0guRWooYikrJyIuJykpCnA9
+dC5OCkMuTm0uVUcocS5kLDAsUC5POChyLmQubGVuZ3RoLCIuLiIsITEscCkpCkMuTm0uWTUocS5lLDAs
+IiIpCkMuTm0uVUcocS5lLDEsUC5POChyLmQubGVuZ3RoLHMuZ21JKCksITEscCkpCnM9cS5kCnA9cy5s
+ZW5ndGgKaWYocD09PTApcmV0dXJuIi4iCmlmKHA+MSYmSi5STShDLk5tLmdyWihzKSwiLiIpKXtzPXEu
+ZAppZigwPj1zLmxlbmd0aClyZXR1cm4gSC5PSChzLC0xKQpzLnBvcCgpCnM9cS5lCmlmKDA+PXMubGVu
+Z3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKaWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywt
+MSkKcy5wb3AoKQpDLk5tLmkocywiIil9cS5iPSIiCnEuSXgoKQpyZXR1cm4gcS53KDApfX0KTS5xNy5w
+cm90b3R5cGU9ewokMTpmdW5jdGlvbihhKXtyZXR1cm4gSC5oKGEpIT09IiJ9LAokUzo2fQpNLk5vLnBy
+b3RvdHlwZT17CiQxOmZ1bmN0aW9uKGEpe0guayhhKQpyZXR1cm4gYT09bnVsbD8ibnVsbCI6JyInK2Er
+JyInfSwKJFM6NTB9CkIuZnYucHJvdG90eXBlPXsKeFo6ZnVuY3Rpb24oYSl7dmFyIHMscj10aGlzLlly
+KGEpCmlmKHI+MClyZXR1cm4gSi5sZChhLDAscikKaWYodGhpcy5oSyhhKSl7aWYoMD49YS5sZW5ndGgp
+cmV0dXJuIEguT0goYSwwKQpzPWFbMF19ZWxzZSBzPW51bGwKcmV0dXJuIHN9LApOYzpmdW5jdGlvbihh
+LGIpe3JldHVybiBhPT1ifX0KWC5XRC5wcm90b3R5cGU9ewpJeDpmdW5jdGlvbigpe3ZhciBzLHIscT10
+aGlzCndoaWxlKCEwKXtzPXEuZAppZighKHMubGVuZ3RoIT09MCYmSi5STShDLk5tLmdyWihzKSwiIikp
+KWJyZWFrCnM9cS5kCmlmKDA+PXMubGVuZ3RoKXJldHVybiBILk9IKHMsLTEpCnMucG9wKCkKcz1xLmUK
+aWYoMD49cy5sZW5ndGgpcmV0dXJuIEguT0gocywtMSkKcy5wb3AoKX1zPXEuZQpyPXMubGVuZ3RoCmlm
+KHIhPT0wKUMuTm0uWTUocyxyLTEsIiIpfSwKclI6ZnVuY3Rpb24oKXt2YXIgcyxyLHEscCxvLG4sbT10
+aGlzLGw9SC5WTShbXSx0LnMpCmZvcihzPW0uZCxyPXMubGVuZ3RoLHE9MCxwPTA7cDxzLmxlbmd0aDtz
+Lmxlbmd0aD09PXJ8fCgwLEgubGspKHMpLCsrcCl7bz1zW3BdCm49Si5pYShvKQppZighKG4uRE4obywi
+LiIpfHxuLkROKG8sIiIpKSlpZihuLkROKG8sIi4uIikpe249bC5sZW5ndGgKaWYobiE9PTApe2lmKDA+
+PW4pcmV0dXJuIEguT0gobCwtMSkKbC5wb3AoKX1lbHNlICsrcX1lbHNlIEMuTm0uaShsLG8pfWlmKG0u
+Yj09bnVsbClDLk5tLlVHKGwsMCxQLk84KHEsIi4uIiwhMSx0Lk4pKQppZihsLmxlbmd0aD09PTAmJm0u
+Yj09bnVsbClDLk5tLmkobCwiLiIpCm0uc25KKGwpCnM9bS5hCm0uc1BoKFAuTzgobC5sZW5ndGgrMSxz
+LmdtSSgpLCEwLHQuTikpCnI9bS5iCmlmKHI9PW51bGx8fGwubGVuZ3RoPT09MHx8IXMuZHMocikpQy5O
+bS5ZNShtLmUsMCwiIikKcj1tLmIKaWYociE9bnVsbCYmcz09PSQuS2soKSl7ci50b1N0cmluZwptLmI9
+SC55cyhyLCIvIiwiXFwiKX1tLkl4KCl9LAp3OmZ1bmN0aW9uKGEpe3ZhciBzLHIscT10aGlzLHA9cS5i
+CnA9cCE9bnVsbD9wOiIiCmZvcihzPTA7czxxLmQubGVuZ3RoOysrcyl7cj1xLmUKaWYocz49ci5sZW5n
+dGgpcmV0dXJuIEguT0gocixzKQpyPXArSC5FaihyW3NdKQpwPXEuZAppZihzPj1wLmxlbmd0aClyZXR1
+cm4gSC5PSChwLHMpCnA9citILkVqKHBbc10pfXArPUguRWooQy5ObS5ncloocS5lKSkKcmV0dXJuIHAu
+Y2hhckNvZGVBdCgwKT09MD9wOnB9LApzbko6ZnVuY3Rpb24oYSl7dGhpcy5kPXQuRC5hKGEpfSwKc1Bo
+OmZ1bmN0aW9uKGEpe3RoaXMuZT10LkQuYShhKX19ClguZHYucHJvdG90eXBlPXsKdzpmdW5jdGlvbihh
+KXtyZXR1cm4iUGF0aEV4Y2VwdGlvbjogIit0aGlzLmF9LAokaVJ6OjF9Ck8uekwucHJvdG90eXBlPXsK
+dzpmdW5jdGlvbihhKXtyZXR1cm4gdGhpcy5nb2ModGhpcyl9fQpFLk9GLnByb3RvdHlwZT17ClVkOmZ1
+bmN0aW9uKGEpe3JldHVybiBDLnhCLnRnKGEsIi8iKX0sCnI0OmZ1bmN0aW9uKGEpe3JldHVybiBhPT09
+NDd9LApkczpmdW5jdGlvbihhKXt2YXIgcz1hLmxlbmd0aApyZXR1cm4gcyE9PTAmJkMueEIuTzIoYSxz
+LTEpIT09NDd9LApTcDpmdW5jdGlvbihhLGIpe2lmKGEubGVuZ3RoIT09MCYmQy54Qi5XKGEsMCk9PT00
+NylyZXR1cm4gMQpyZXR1cm4gMH0sCllyOmZ1bmN0aW9uKGEpe3JldHVybiB0aGlzLlNwKGEsITEpfSwK
+aEs6ZnVuY3Rpb24oYSl7cmV0dXJuITF9LApnb2M6ZnVuY3Rpb24oKXtyZXR1cm4icG9zaXgifSwKZ21J
+OmZ1bmN0aW9uKCl7cmV0dXJuIi8ifX0KRi5ydS5wcm90b3R5cGU9ewpVZDpmdW5jdGlvbihhKXtyZXR1
+cm4gQy54Qi50ZyhhLCIvIil9LApyNDpmdW5jdGlvbihhKXtyZXR1cm4gYT09PTQ3fSwKZHM6ZnVuY3Rp
+b24oYSl7dmFyIHM9YS5sZW5ndGgKaWYocz09PTApcmV0dXJuITEKaWYoQy54Qi5PMihhLHMtMSkhPT00
+NylyZXR1cm4hMApyZXR1cm4gQy54Qi5UYyhhLCI6Ly8iKSYmdGhpcy5ZcihhKT09PXN9LApTcDpmdW5j
+dGlvbihhLGIpe3ZhciBzLHIscSxwLG89YS5sZW5ndGgKaWYobz09PTApcmV0dXJuIDAKaWYoQy54Qi5X
+KGEsMCk9PT00NylyZXR1cm4gMQpmb3Iocz0wO3M8bzsrK3Mpe3I9Qy54Qi5XKGEscykKaWYocj09PTQ3
+KXJldHVybiAwCmlmKHI9PT01OCl7aWYocz09PTApcmV0dXJuIDAKcT1DLnhCLlhVKGEsIi8iLEMueEIu
+UWkoYSwiLy8iLHMrMSk/cyszOnMpCmlmKHE8PTApcmV0dXJuIG8KaWYoIWJ8fG88cSszKXJldHVybiBx
+CmlmKCFDLnhCLm5DKGEsImZpbGU6Ly8iKSlyZXR1cm4gcQppZighQi5ZdShhLHErMSkpcmV0dXJuIHEK
+cD1xKzMKcmV0dXJuIG89PT1wP3A6cSs0fX1yZXR1cm4gMH0sCllyOmZ1bmN0aW9uKGEpe3JldHVybiB0
+aGlzLlNwKGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuIGEubGVuZ3RoIT09MCYmQy54Qi5XKGEs
+MCk9PT00N30sCmdvYzpmdW5jdGlvbigpe3JldHVybiJ1cmwifSwKZ21JOmZ1bmN0aW9uKCl7cmV0dXJu
+Ii8ifX0KTC5JVi5wcm90b3R5cGU9ewpVZDpmdW5jdGlvbihhKXtyZXR1cm4gQy54Qi50ZyhhLCIvIil9
+LApyNDpmdW5jdGlvbihhKXtyZXR1cm4gYT09PTQ3fHxhPT09OTJ9LApkczpmdW5jdGlvbihhKXt2YXIg
+cz1hLmxlbmd0aAppZihzPT09MClyZXR1cm4hMQpzPUMueEIuTzIoYSxzLTEpCnJldHVybiEocz09PTQ3
+fHxzPT09OTIpfSwKU3A6ZnVuY3Rpb24oYSxiKXt2YXIgcyxyLHE9YS5sZW5ndGgKaWYocT09PTApcmV0
+dXJuIDAKcz1DLnhCLlcoYSwwKQppZihzPT09NDcpcmV0dXJuIDEKaWYocz09PTkyKXtpZihxPDJ8fEMu
+eEIuVyhhLDEpIT09OTIpcmV0dXJuIDEKcj1DLnhCLlhVKGEsIlxcIiwyKQppZihyPjApe3I9Qy54Qi5Y
+VShhLCJcXCIscisxKQppZihyPjApcmV0dXJuIHJ9cmV0dXJuIHF9aWYocTwzKXJldHVybiAwCmlmKCFC
+Lk9TKHMpKXJldHVybiAwCmlmKEMueEIuVyhhLDEpIT09NTgpcmV0dXJuIDAKcT1DLnhCLlcoYSwyKQpp
+ZighKHE9PT00N3x8cT09PTkyKSlyZXR1cm4gMApyZXR1cm4gM30sCllyOmZ1bmN0aW9uKGEpe3JldHVy
+biB0aGlzLlNwKGEsITEpfSwKaEs6ZnVuY3Rpb24oYSl7cmV0dXJuIHRoaXMuWXIoYSk9PT0xfSwKT3Q6
+ZnVuY3Rpb24oYSxiKXt2YXIgcwppZihhPT09YilyZXR1cm4hMAppZihhPT09NDcpcmV0dXJuIGI9PT05
+MgppZihhPT09OTIpcmV0dXJuIGI9PT00NwppZigoYV5iKSE9PTMyKXJldHVybiExCnM9YXwzMgpyZXR1
+cm4gcz49OTcmJnM8PTEyMn0sCk5jOmZ1bmN0aW9uKGEsYil7dmFyIHMscixxCmlmKGE9PWIpcmV0dXJu
+ITAKcz1hLmxlbmd0aAppZihzIT09Yi5sZW5ndGgpcmV0dXJuITEKZm9yKHI9Si5yWShiKSxxPTA7cTxz
+OysrcSlpZighdGhpcy5PdChDLnhCLlcoYSxxKSxyLlcoYixxKSkpcmV0dXJuITEKcmV0dXJuITB9LApn
+b2M6ZnVuY3Rpb24oKXtyZXR1cm4id2luZG93cyJ9LApnbUk6ZnVuY3Rpb24oKXtyZXR1cm4iXFwifX07
+KGZ1bmN0aW9uIGFsaWFzZXMoKXt2YXIgcz1KLkd2LnByb3RvdHlwZQpzLlU9cy53CnMuU2o9cy5lNwpz
+PUouTUYucHJvdG90eXBlCnMudD1zLncKcz1QLmNYLnByb3RvdHlwZQpzLkdHPXMuZXYKcz1QLk1oLnBy
+b3RvdHlwZQpzLnhiPXMudwpzPVcuY3YucHJvdG90eXBlCnMuRFc9cy5yNgpzPVcubTYucHJvdG90eXBl
+CnMuakY9cy5FYgpzPVAuRTQucHJvdG90eXBlCnMuVXI9cy5xCnMuZTQ9cy5ZNX0pKCk7KGZ1bmN0aW9u
+IGluc3RhbGxUZWFyT2Zmcygpe3ZhciBzPWh1bmtIZWxwZXJzLl9zdGF0aWNfMSxyPWh1bmtIZWxwZXJz
+Ll9zdGF0aWNfMCxxPWh1bmtIZWxwZXJzLmluc3RhbGxJbnN0YW5jZVRlYXJPZmYscD1odW5rSGVscGVy
+cy5pbnN0YWxsU3RhdGljVGVhck9mZixvPWh1bmtIZWxwZXJzLl9pbnN0YW5jZV8xdQpzKFAsIkVYIiwi
+WlYiLDcpCnMoUCwieXQiLCJvQSIsNykKcyhQLCJxVyIsIkJ6Iiw3KQpyKFAsIlVJIiwiZU4iLDApCnEo
+UC5QZi5wcm90b3R5cGUsImdZSiIsMCwxLG51bGwsWyIkMiIsIiQxIl0sWyJ3MCIsInBtIl0sMjgsMCkK
+cyhQLCJDeSIsIk5DIiw0KQpzKFAsIlBIIiwiTXQiLDUpCnAoVywicFMiLDQsbnVsbCxbIiQ0Il0sWyJx
+RCJdLDgsMCkKcChXLCJWNCIsNCxudWxsLFsiJDQiXSxbIlFXIl0sOCwwKQpvKFAuQXMucHJvdG90eXBl
+LCJndU0iLCJWIiw1KQpzKFAsImlHIiwid1kiLDUzKQpzKFAsIncwIiwiZFUiLDM2KQpzKEwsImlTIiwi
+aTYiLDIwKX0pKCk7KGZ1bmN0aW9uIGluaGVyaXRhbmNlKCl7dmFyIHM9aHVua0hlbHBlcnMubWl4aW4s
+cj1odW5rSGVscGVycy5pbmhlcml0LHE9aHVua0hlbHBlcnMuaW5oZXJpdE1hbnkKcihQLk1oLG51bGwp
+CnEoUC5NaCxbSC5GSyxKLkd2LEoubTEsUC5jWCxILkU3LFAuWFMsUC5uWSxILmE3LFAuQW4sSC5GdSxI
+LkpCLEguU1UsSC5SZSxILnd2LFAuUG4sSC5XVSxILkxJLEguVHAsSC5mOSxILnRlLEguYnEsSC5YTyxI
+LmtyLFAuWWssSC52aCxILk42LEguVlIsSC5FSyxILlBiLEgudFEsSC5TZCxILkpjLEguRyxILmxZLFAu
+VzMsUC5paCxQLkZ5LFAuR1YsUC5QZixQLkZlLFAudnMsUC5PTSxQLnFoLFAuTU8sUC5rVCxQLnhJLFAu
+Q3csUC5tMCxQLnBSLFAuYm4sUC5sbSxQLmxELFAuS1AsUC5sZixQLldZLFAuVWssUC5TaCxQLlJ3LFAu
+YnosUC5pUCxQLms1LFAuS1ksUC5DRCxQLmFFLFAuTjMsUC5jOCxQLlpkLFAuUm4sUC5EbixQLlBFLFAu
+VWYsVy5pZCxXLkZrLFcuSlEsVy5HbSxXLnZELFcubTYsVy5PdyxXLlc5LFcuZFcsVy5tayxXLktvLFAu
+aUosUC5FNCxNLkg3LFUuTEwsVS5kMixVLlNlLFUuTWwsVS55RCxVLndiLEIuajgsQi5xcCxULm1RLEwu
+WEEsTC5EOCxMLk85LEwuR2IsTS5sSSxPLnpMLFguV0QsWC5kdl0pCnEoSi5HdixbSi55RSxKLndlLEou
+TUYsSi5qZCxKLnFJLEouRHIsSC5FVCxXLkQwLFcuQXosVy5MZSxXLk5oLFcuYWUsVy5JQixXLm43LFcu
+ZWEsVy5icixXLlNnLFcudzcsVy5LNyxXLlhXLFAuaEZdKQpxKEouTUYsW0ouaUMsSi5rZCxKLmM1XSkK
+cihKLlBvLEouamQpCnEoSi5xSSxbSi5iVSxKLlZBXSkKcShQLmNYLFtILkJSLEguYlEsSC5pMSxILlU1
+LEguQU0sSC51NixILlhSLFAubVcsSC51bl0pCnEoSC5CUixbSC5aeSxILlFDXSkKcihILm9sLEguWnkp
+CnIoSC5VcSxILlFDKQpyKEgualYsSC5VcSkKcShQLlhTLFtILm4sSC5yMyxILkdNLFAuRXosSC5heixI
+LnZWLEguRXEsUC5DNixILmtTLFAuVWQsUC5GLFAudSxQLm1wLFAudWIsUC5kcyxQLmxqLFAuVVYsUC5j
+XSkKcihQLnV5LFAublkpCnEoUC51eSxbSC53MixXLnd6LFcuZTddKQpyKEgucWosSC53MikKcShILmJR
+LFtILmFMLEguTUIsSC5pNV0pCnEoSC5hTCxbSC5uSCxILmxKLFAuaThdKQpyKEgueHksSC5pMSkKcShQ
+LkFuLFtILk1ILEguU08sSC5VMV0pCnIoSC5kNSxILkFNKQpyKFAuUlUsUC5QbikKcihQLkdqLFAuUlUp
+CnIoSC5QRCxQLkdqKQpyKEguTFAsSC5XVSkKcShILlRwLFtILkNqLEgubGMsSC5kQyxILndOLEguVlgs
+UC50aCxQLmhhLFAuVnMsUC5GdCxQLnlILFAuV00sUC5TWCxQLkdzLFAuZGEsUC5vUSxQLnBWLFAuVTcs
+UC52cixQLnJ0LFAuS0YsUC5aTCxQLlJULFAualosUC5ycSxQLlJXLFAuQjUsUC51TyxQLnBLLFAuaGos
+UC5WcCxQLk9SLFAucmEsUC55USxQLnhyLFAuTnosUC50aSxQLldGLFAubjEsUC5jUyxQLlZDLFAuSlQs
+UC5SWixQLk1FLFAueTUsUC55SSxQLmM2LFAucWQsVy5DdixXLktTLFcuQTMsVy52TixXLlV2LFcuRWcs
+Vy5FbyxXLldrLFcuSUEsVy5mbSxQLmpnLFAuVGEsUC5HRSxQLk43LFAudVEsUC5QQyxQLm10LFAuUVMs
+UC5ucCxQLlV0LFUuTUQsVS5hTixVLmIwLEwuZSxMLlZXLEwub1osTC5qcixMLnFsLEwuSGksTC5CVCxM
+LlBZLEwudTgsTC5MLEwuV3gsTC5BTyxMLmROLEwuSG8sTC54eixMLklDLEwuZkMsTC5uVCxMLk5ZLEwu
+dWUsTC5lWCxMLkVFLEwuUUwsTC5WUyxMLlRELEwubTIsTS5xNyxNLk5vXSkKcihILlcwLFAuRXopCnEo
+SC5sYyxbSC56eCxILnJUXSkKcihILmtZLFAuQzYpCnIoUC5pbCxQLllrKQpxKFAuaWwsW0guTjUsUC51
+dyxXLmNmLFcuU3ldKQpxKFAubVcsW0guS1csUC5xNF0pCnIoSC5MWixILkVUKQpxKEguTFosW0guUkcs
+SC5XQl0pCnIoSC5WUCxILlJHKQpyKEguRGcsSC5WUCkKcihILlpHLEguV0IpCnIoSC5QZyxILlpHKQpx
+KEguUGcsW0gueGosSC5kRSxILlpBLEguZFQsSC5QcSxILmVFLEguVjZdKQpyKEguaU0sSC5rUykKcihQ
+LlpmLFAuUGYpCnIoUC5KaSxQLm0wKQpyKFAuWHYsUC5wUikKcihQLmI2LFAuWHYpCnIoUC5WaixQLldZ
+KQpxKFAuVWssW1AuQ1YsUC5aaSxQLmJ5XSkKcihQLndJLFAua1QpCnEoUC53SSxbUC5VOCxQLm9qLFAu
+TXgsUC5FMyxQLkdZXSkKcihQLks4LFAuVWQpCnIoUC50dSxQLlNoKQpyKFAudTUsUC5aaSkKcShQLnUs
+W1AuYkosUC5lWV0pCnIoUC5xZSxQLkRuKQpxKFcuRDAsW1cudUgsVy53YSxXLks1LFcuQ21dKQpxKFcu
+dUgsW1cuY3YsVy5ueCxXLlFGLFcuQ1FdKQpxKFcuY3YsW1cucUUsUC5oaV0pCnEoVy5xRSxbVy5HaCxX
+LmZZLFcubkIsVy5RUCxXLmg0LFcuU04sVy5scCxXLlRiLFcuSXYsVy5XUCxXLnlZXSkKcihXLm9KLFcu
+TGUpCnIoVy5oSCxXLkF6KQpyKFcuVmIsVy5RRikKcihXLmZKLFcud2EpCnEoVy5lYSxbVy53NixXLmV3
+XSkKcihXLkFqLFcudzYpCnIoVy5yQixXLks3KQpyKFcuQkgsVy5yQikKcihXLnc0LFcuSUIpCnIoVy5v
+YSxXLlhXKQpyKFcucmgsVy5vYSkKcihXLmk3LFcuY2YpCnIoUC5BcyxQLlZqKQpxKFAuQXMsW1cuSTQs
+UC5LZV0pCnIoVy5STyxQLnFoKQpyKFcuZXUsVy5STykKcihXLnhDLFAuTU8pCnIoVy5jdCxXLm02KQpy
+KFAuQmYsUC5pSikKcShQLkU0LFtQLnI3LFAuY29dKQpyKFAuVHosUC5jbykKcihQLm5kLFAuaGkpCnEo
+TC5EOCxbTC52dCxMLmNEXSkKcihCLmZ2LE8uekwpCnEoQi5mdixbRS5PRixGLnJ1LEwuSVZdKQpzKEgu
+dzIsSC5SZSkKcyhILlFDLFAubEQpCnMoSC5SRyxQLmxEKQpzKEguVlAsSC5TVSkKcyhILldCLFAubEQp
+CnMoSC5aRyxILlNVKQpzKFAublksUC5sRCkKcyhQLldZLFAubGYpCnMoUC5SVSxQLktQKQpzKFAucFIs
+UC5sZikKcyhXLkxlLFcuaWQpCnMoVy5LNyxQLmxEKQpzKFcuckIsVy5HbSkKcyhXLlhXLFAubEQpCnMo
+Vy5vYSxXLkdtKQpzKFAuY28sUC5sRCl9KSgpCnZhciB2PXt0eXBlVW5pdmVyc2U6e2VDOm5ldyBNYXAo
+KSx0Ujp7fSxlVDp7fSx0UFY6e30sc0VBOltdfSxtYW5nbGVkR2xvYmFsTmFtZXM6e0lmOiJpbnQiLENQ
+OiJkb3VibGUiLFpaOiJudW0iLHFVOiJTdHJpbmciLGEyOiJib29sIixjODoiTnVsbCIsek06Ikxpc3Qi
+fSxtYW5nbGVkTmFtZXM6e30sZ2V0VHlwZUZyb21OYW1lOmdldEdsb2JhbEZyb21OYW1lLG1ldGFkYXRh
+OltdLHR5cGVzOlsifigpIiwiYzgoQWoqKSIsImM4KCkiLCJjOChjdiopIiwiQChAKSIsInFVKHFVKSIs
+ImEyKHFVKSIsIn4ofigpKSIsImEyKGN2LHFVLHFVLEpRKSIsImM4KEApIiwifihNaD8sTWg/KSIsIkAo
+KSIsIn4ocVUsQCkiLCJ+KG42LHFVLElmKSIsIn4ocVUscVUpIiwiYTIoa0YpIiwiYzgoQCxAKSIsIn4o
+eHU8cVU+KSIsImM4KGVhKikiLCJiODxjOD4qKEFqKikiLCJ+KEFqKikiLCJ+KHFVLElmKSIsIn4ocVUs
+cVU/KSIsIm42KEAsQCkiLCJjOChALEd6KSIsImEyKHVIKSIsIn4oSWYsQCkiLCJ+KGVhKSIsIn4oTWhb
+R3o/XSkiLCJjOChNaCxHeikiLCJ+KHVILHVIPykiLCJ+KEAsQCkiLCJ2czxAPihAKSIsImEyKHh1PHFV
+PikiLCJjOCh+KCkpIiwicjcoQCkiLCJNaD8oQCkiLCJFNChAKSIsImEyKihINyopIiwiTEwqKEApIiwi
+WjA8cVUqLE1oKj4qKExMKikiLCJAKHFVKSIsIn4oR0QsQCkiLCJjOChaMDxxVSosTWgqPiopIiwiWjA8
+cVUscVU+KFowPHFVLHFVPixxVSkiLCJxVSooQWoqKSIsIkAoQCxxVSkiLCJjOChldyopIiwicVUqKFow
+PEAsQD4qKSIsIn4ocVVbQF0pIiwicVUocVU/KSIsIklmKElmLElmKSIsIn4oQCkiLCJNaD8oTWg/KSIs
+IlR6PEA+KEApIl0saW50ZXJjZXB0b3JzQnlUYWc6bnVsbCxsZWFmVGFnczpudWxsLGFycmF5UnRpOnR5
+cGVvZiBTeW1ib2w9PSJmdW5jdGlvbiImJnR5cGVvZiBTeW1ib2woKT09InN5bWJvbCI/U3ltYm9sKCIk
+dGkiKToiJHRpIn0KSC54Yih2LnR5cGVVbml2ZXJzZSxKU09OLnBhcnNlKCd7ImM1IjoiTUYiLCJpQyI6
+Ik1GIiwia2QiOiJNRiIsInJ4IjoiZWEiLCJlNSI6ImVhIiwiWTAiOiJoaSIsInRwIjoiaGkiLCJHOCI6
+ImV3IiwiTXIiOiJxRSIsImVMIjoicUUiLCJJMCI6InVIIiwiaHMiOiJ1SCIsIlhnIjoiUUYiLCJuciI6
+IkFqIiwieTQiOiJ3NiIsImFQIjoiQ20iLCJ4YyI6Im54Iiwia0oiOiJueCIsInpVIjoiRGciLCJkZiI6
+IkVUIiwieUUiOnsiYTIiOltdfSwid2UiOnsiYzgiOltdfSwiTUYiOnsidm0iOltdLCJFSCI6W119LCJq
+ZCI6eyJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiUG8iOnsiamQiOlsiMSJdLCJ6TSI6
+WyIxIl0sImJRIjpbIjEiXSwiY1giOlsiMSJdfSwibTEiOnsiQW4iOlsiMSJdfSwicUkiOnsiQ1AiOltd
+LCJaWiI6W119LCJiVSI6eyJDUCI6W10sIklmIjpbXSwiWloiOltdfSwiVkEiOnsiQ1AiOltdLCJaWiI6
+W119LCJEciI6eyJxVSI6W10sInZYIjpbXX0sIkJSIjp7ImNYIjpbIjIiXX0sIkU3Ijp7IkFuIjpbIjIi
+XX0sIlp5Ijp7IkJSIjpbIjEiLCIyIl0sImNYIjpbIjIiXSwiY1guRSI6IjIifSwib2wiOnsiWnkiOlsi
+MSIsIjIiXSwiQlIiOlsiMSIsIjIiXSwiYlEiOlsiMiJdLCJjWCI6WyIyIl0sImNYLkUiOiIyIn0sIlVx
+Ijp7ImxEIjpbIjIiXSwiek0iOlsiMiJdLCJCUiI6WyIxIiwiMiJdLCJiUSI6WyIyIl0sImNYIjpbIjIi
+XX0sImpWIjp7IlVxIjpbIjEiLCIyIl0sImxEIjpbIjIiXSwiek0iOlsiMiJdLCJCUiI6WyIxIiwiMiJd
+LCJiUSI6WyIyIl0sImNYIjpbIjIiXSwibEQuRSI6IjIiLCJjWC5FIjoiMiJ9LCJuIjp7IlhTIjpbXX0s
+InIzIjp7IlhTIjpbXX0sInFqIjp7ImxEIjpbIklmIl0sIlJlIjpbIklmIl0sInpNIjpbIklmIl0sImJR
+IjpbIklmIl0sImNYIjpbIklmIl0sImxELkUiOiJJZiIsIlJlLkUiOiJJZiJ9LCJHTSI6eyJYUyI6W119
+LCJiUSI6eyJjWCI6WyIxIl19LCJhTCI6eyJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIm5IIjp7ImFMIjpb
+IjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImFMLkUiOiIxIiwiY1guRSI6IjEifSwiYTciOnsiQW4i
+OlsiMSJdfSwiaTEiOnsiY1giOlsiMiJdLCJjWC5FIjoiMiJ9LCJ4eSI6eyJpMSI6WyIxIiwiMiJdLCJi
+USI6WyIyIl0sImNYIjpbIjIiXSwiY1guRSI6IjIifSwiTUgiOnsiQW4iOlsiMiJdfSwibEoiOnsiYUwi
+OlsiMiJdLCJiUSI6WyIyIl0sImNYIjpbIjIiXSwiYUwuRSI6IjIiLCJjWC5FIjoiMiJ9LCJVNSI6eyJj
+WCI6WyIxIl0sImNYLkUiOiIxIn0sIlNPIjp7IkFuIjpbIjEiXX0sIkFNIjp7ImNYIjpbIjEiXSwiY1gu
+RSI6IjEifSwiZDUiOnsiQU0iOlsiMSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwiY1guRSI6IjEifSwi
+VTEiOnsiQW4iOlsiMSJdfSwiTUIiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIxIn0sIkZ1
+Ijp7IkFuIjpbIjEiXX0sInU2Ijp7ImNYIjpbIjEiXSwiY1guRSI6IjEifSwiSkIiOnsiQW4iOlsiMSJd
+fSwidzIiOnsibEQiOlsiMSJdLCJSZSI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIx
+Il19LCJ3diI6eyJHRCI6W119LCJQRCI6eyJHaiI6WyIxIiwiMiJdLCJSVSI6WyIxIiwiMiJdLCJQbiI6
+WyIxIiwiMiJdLCJLUCI6WyIxIiwiMiJdLCJaMCI6WyIxIiwiMiJdfSwiV1UiOnsiWjAiOlsiMSIsIjIi
+XX0sIkxQIjp7IldVIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19LCJYUiI6eyJjWCI6WyIxIl0sImNY
+LkUiOiIxIn0sIkxJIjp7InZRIjpbXX0sIlcwIjp7IlhTIjpbXX0sImF6Ijp7IlhTIjpbXX0sInZWIjp7
+IlhTIjpbXX0sInRlIjp7IlJ6IjpbXX0sIlhPIjp7Ikd6IjpbXX0sIlRwIjp7IkVIIjpbXX0sImxjIjp7
+IkVIIjpbXX0sInp4Ijp7IkVIIjpbXX0sInJUIjp7IkVIIjpbXX0sIkVxIjp7IlhTIjpbXX0sImtZIjp7
+IlhTIjpbXX0sIk41Ijp7IllrIjpbIjEiLCIyIl0sIkZvIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl0s
+IllrLksiOiIxIiwiWWsuViI6IjIifSwiaTUiOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImNYLkUiOiIx
+In0sIk42Ijp7IkFuIjpbIjEiXX0sIlZSIjp7IndMIjpbXSwidlgiOltdfSwiRUsiOnsiaWIiOltdLCJP
+ZCI6W119LCJLVyI6eyJjWCI6WyJpYiJdLCJjWC5FIjoiaWIifSwiUGIiOnsiQW4iOlsiaWIiXX0sInRR
+Ijp7Ik9kIjpbXX0sInVuIjp7ImNYIjpbIk9kIl0sImNYLkUiOiJPZCJ9LCJTZCI6eyJBbiI6WyJPZCJd
+fSwiRVQiOnsiQVMiOltdfSwiTFoiOnsiWGoiOlsiMSJdLCJFVCI6W10sIkFTIjpbXX0sIkRnIjp7ImxE
+IjpbIkNQIl0sIlhqIjpbIkNQIl0sInpNIjpbIkNQIl0sIkVUIjpbXSwiYlEiOlsiQ1AiXSwiQVMiOltd
+LCJjWCI6WyJDUCJdLCJTVSI6WyJDUCJdLCJsRC5FIjoiQ1AifSwiUGciOnsibEQiOlsiSWYiXSwiWGoi
 OlsiSWYiXSwiek0iOlsiSWYiXSwiRVQiOltdLCJiUSI6WyJJZiJdLCJBUyI6W10sImNYIjpbIklmIl0s
-IlNVIjpbIklmIl0sImxELkUiOiJJZiJ9LCJQcSI6eyJsRCI6WyJJZiJdLCJYaiI6WyJJZiJdLCJ6TSI6
-WyJJZiJdLCJFVCI6W10sImJRIjpbIklmIl0sIkFTIjpbXSwiY1giOlsiSWYiXSwiU1UiOlsiSWYiXSwi
-bEQuRSI6IklmIn0sImVFIjp7ImxEIjpbIklmIl0sIlhqIjpbIklmIl0sInpNIjpbIklmIl0sIkVUIjpb
-XSwiYlEiOlsiSWYiXSwiQVMiOltdLCJjWCI6WyJJZiJdLCJTVSI6WyJJZiJdLCJsRC5FIjoiSWYifSwi
-VjYiOnsibEQiOlsiSWYiXSwibjYiOltdLCJYaiI6WyJJZiJdLCJ6TSI6WyJJZiJdLCJFVCI6W10sImJR
-IjpbIklmIl0sIkFTIjpbXSwiY1giOlsiSWYiXSwiU1UiOlsiSWYiXSwibEQuRSI6IklmIn0sImtTIjp7
-IlhTIjpbXX0sImlNIjp7IlhTIjpbXX0sIkdWIjp7IkFuIjpbIjEiXX0sInE0Ijp7ImNYIjpbIjEiXSwi
-Y1guRSI6IjEifSwiWmYiOnsiUGYiOlsiMSJdfSwidnMiOnsiYjgiOlsiMSJdfSwiQ3ciOnsiWFMiOltd
-fSwibTAiOnsiUW0iOltdfSwiSmkiOnsibTAiOltdLCJRbSI6W119LCJiNiI6eyJsZiI6WyIxIl0sInh1
-IjpbIjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl0sImxmLkUiOiIxIn0sImxtIjp7IkFuIjpbIjEiXX0s
-Im1XIjp7ImNYIjpbIjEiXX0sInV5Ijp7ImxEIjpbIjEiXSwiek0iOlsiMSJdLCJiUSI6WyIxIl0sImNY
-IjpbIjEiXX0sImlsIjp7IllrIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19LCJZayI6eyJaMCI6WyIx
-IiwiMiJdfSwiUG4iOnsiWjAiOlsiMSIsIjIiXX0sIkdqIjp7IlJVIjpbIjEiLCIyIl0sIlBuIjpbIjEi
-LCIyIl0sIktQIjpbIjEiLCIyIl0sIlowIjpbIjEiLCIyIl19LCJWaiI6eyJsZiI6WyIxIl0sInh1Ijpb
-IjEiXSwiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJYdiI6eyJsZiI6WyIxIl0sInh1IjpbIjEiXSwiYlEi
-OlsiMSJdLCJjWCI6WyIxIl19LCJ1dyI6eyJZayI6WyJxVSIsIkAiXSwiWjAiOlsicVUiLCJAIl0sIllr
-LksiOiJxVSIsIllrLlYiOiJAIn0sImk4Ijp7ImFMIjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFV
-Il0sImFMLkUiOiJxVSIsImNYLkUiOiJxVSJ9LCJDViI6eyJVayI6WyJ6TTxJZj4iLCJxVSJdLCJVay5T
-Ijoiek08SWY+In0sIlU4Ijp7IndJIjpbInpNPElmPiIsInFVIl19LCJaaSI6eyJVayI6WyJxVSIsInpN
-PElmPiJdfSwiVWQiOnsiWFMiOltdfSwiSzgiOnsiWFMiOltdfSwiYnkiOnsiVWsiOlsiTWg/IiwicVUi
-XSwiVWsuUyI6Ik1oPyJ9LCJvaiI6eyJ3SSI6WyJNaD8iLCJxVSJdfSwiTXgiOnsid0kiOlsicVUiLCJN
-aD8iXX0sInU1Ijp7IlVrIjpbInFVIiwiek08SWY+Il0sIlVrLlMiOiJxVSJ9LCJFMyI6eyJ3SSI6WyJx
-VSIsInpNPElmPiJdfSwiR1kiOnsid0kiOlsiek08SWY+IiwicVUiXX0sIkNQIjp7IlpaIjpbXX0sIklm
-Ijp7IlpaIjpbXX0sInpNIjp7ImJRIjpbIjEiXSwiY1giOlsiMSJdfSwiaWIiOnsiT2QiOltdfSwieHUi
-OnsiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJxVSI6eyJ2WCI6W119LCJDNiI6eyJYUyI6W119LCJFeiI6
-eyJYUyI6W119LCJGIjp7IlhTIjpbXX0sInUiOnsiWFMiOltdfSwiYkoiOnsiWFMiOltdfSwiZVkiOnsi
-WFMiOltdfSwibXAiOnsiWFMiOltdfSwidWIiOnsiWFMiOltdfSwiZHMiOnsiWFMiOltdfSwibGoiOnsi
-WFMiOltdfSwiVVYiOnsiWFMiOltdfSwiazUiOnsiWFMiOltdfSwiS1kiOnsiWFMiOltdfSwiYyI6eyJY
-UyI6W119LCJDRCI6eyJSeiI6W119LCJhRSI6eyJSeiI6W119LCJaZCI6eyJHeiI6W119LCJSbiI6eyJC
-TCI6W119LCJEbiI6eyJpRCI6W119LCJVZiI6eyJpRCI6W119LCJxZSI6eyJpRCI6W119LCJxRSI6eyJj
-diI6W10sInVIIjpbXSwiRDAiOltdfSwiR2giOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sImZZIjp7
-ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJuQiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiUVAi
-OnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIm54Ijp7InVIIjpbXSwiRDAiOltdfSwiUUYiOnsidUgi
-OltdLCJEMCI6W119LCJJQiI6eyJ0biI6WyJaWiJdfSwid3oiOnsibEQiOlsiMSJdLCJ6TSI6WyIxIl0s
-ImJRIjpbIjEiXSwiY1giOlsiMSJdLCJsRC5FIjoiMSJ9LCJjdiI6eyJ1SCI6W10sIkQwIjpbXX0sImhI
-Ijp7IkF6IjpbXX0sImg0Ijp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJWYiI6eyJ1SCI6W10sIkQw
-IjpbXX0sImZKIjp7IkQwIjpbXX0sIndhIjp7IkQwIjpbXX0sIkFqIjp7ImVhIjpbXX0sImU3Ijp7ImxE
-IjpbInVIIl0sInpNIjpbInVIIl0sImJRIjpbInVIIl0sImNYIjpbInVIIl0sImxELkUiOiJ1SCJ9LCJ1
-SCI6eyJEMCI6W119LCJCSCI6eyJsRCI6WyJ1SCJdLCJHbSI6WyJ1SCJdLCJ6TSI6WyJ1SCJdLCJYaiI6
-WyJ1SCJdLCJiUSI6WyJ1SCJdLCJjWCI6WyJ1SCJdLCJsRC5FIjoidUgiLCJHbS5FIjoidUgifSwiU04i
-OnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sImV3Ijp7ImVhIjpbXX0sImxwIjp7ImN2IjpbXSwidUgi
-OltdLCJEMCI6W119LCJUYiI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiSXYiOnsiY3YiOltdLCJ1
-SCI6W10sIkQwIjpbXX0sIldQIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJ5WSI6eyJjdiI6W10s
-InVIIjpbXSwiRDAiOltdfSwidzYiOnsiZWEiOltdfSwiSzUiOnsidjYiOltdLCJEMCI6W119LCJDbSI6
-eyJEMCI6W119LCJDUSI6eyJ1SCI6W10sIkQwIjpbXX0sInc0Ijp7InRuIjpbIlpaIl19LCJyaCI6eyJs
-RCI6WyJ1SCJdLCJHbSI6WyJ1SCJdLCJ6TSI6WyJ1SCJdLCJYaiI6WyJ1SCJdLCJiUSI6WyJ1SCJdLCJj
-WCI6WyJ1SCJdLCJsRC5FIjoidUgiLCJHbS5FIjoidUgifSwiY2YiOnsiWWsiOlsicVUiLCJxVSJdLCJa
-MCI6WyJxVSIsInFVIl19LCJpNyI6eyJZayI6WyJxVSIsInFVIl0sIlowIjpbInFVIiwicVUiXSwiWWsu
-SyI6InFVIiwiWWsuViI6InFVIn0sIlN5Ijp7IllrIjpbInFVIiwicVUiXSwiWjAiOlsicVUiLCJxVSJd
-LCJZay5LIjoicVUiLCJZay5WIjoicVUifSwiSTQiOnsibGYiOlsicVUiXSwieHUiOlsicVUiXSwiYlEi
-OlsicVUiXSwiY1giOlsicVUiXSwibGYuRSI6InFVIn0sIlJPIjp7InFoIjpbIjEiXX0sImV1Ijp7IlJP
-IjpbIjEiXSwicWgiOlsiMSJdfSwieEMiOnsiTU8iOlsiMSJdfSwiSlEiOnsia0YiOltdfSwidkQiOnsi
-a0YiOltdfSwibTYiOnsia0YiOltdfSwiY3QiOnsia0YiOltdfSwiT3ciOnsia0YiOltdfSwiVzkiOnsi
-QW4iOlsiMSJdfSwiZFciOnsidjYiOltdLCJEMCI6W119LCJtayI6eyJ5MCI6W119LCJLbyI6eyJvbiI6
-W119LCJBcyI6eyJsZiI6WyJxVSJdLCJ4dSI6WyJxVSJdLCJiUSI6WyJxVSJdLCJjWCI6WyJxVSJdfSwi
-cjciOnsiRTQiOltdfSwiVHoiOnsibEQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiRTQiOltd
-LCJjWCI6WyIxIl0sImxELkUiOiIxIn0sIm5kIjp7ImhpIjpbXSwiY3YiOltdLCJ1SCI6W10sIkQwIjpb
-XX0sIktlIjp7ImxmIjpbInFVIl0sInh1IjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFVIl0sImxm
-LkUiOiJxVSJ9LCJoaSI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiWEEiOnsia0YiOltdfSwidnQi
-OnsiRDgiOltdfSwiY0QiOnsiRDgiOltdfSwiZHYiOnsiUnoiOltdfSwiT0YiOnsiZnYiOltdfSwicnUi
-OnsiZnYiOltdfSwiSVYiOnsiZnYiOltdfSwibjYiOnsiek0iOlsiSWYiXSwiYlEiOlsiSWYiXSwiY1gi
-OlsiSWYiXSwiQVMiOltdfX0nKSkKSC5GRih2LnR5cGVVbml2ZXJzZSxKU09OLnBhcnNlKCd7IncyIjox
-LCJRQyI6MiwiTFoiOjEsImtUIjoyLCJtVyI6MSwidXkiOjEsImlsIjoyLCJWaiI6MSwiWHYiOjEsIm5Z
-IjoxLCJXWSI6MSwicFIiOjEsImNvIjoxfScpKQp2YXIgdT17bDoiQ2Fubm90IGV4dHJhY3QgYSBmaWxl
-IHBhdGggZnJvbSBhIFVSSSB3aXRoIGEgZnJhZ21lbnQgY29tcG9uZW50IixpOiJDYW5ub3QgZXh0cmFj
-dCBhIGZpbGUgcGF0aCBmcm9tIGEgVVJJIHdpdGggYSBxdWVyeSBjb21wb25lbnQiLGo6IkNhbm5vdCBl
-eHRyYWN0IGEgbm9uLVdpbmRvd3MgZmlsZSBwYXRoIGZyb20gYSBmaWxlIFVSSSB3aXRoIGFuIGF1dGhv
-cml0eSIsZzoiYG51bGxgIGVuY291bnRlcmVkIGFzIHRoZSByZXN1bHQgZnJvbSBleHByZXNzaW9uIHdp
-dGggdHlwZSBgTmV2ZXJgLiIsZDoiYXJlYS1hbmFseXplcixhbmFseXplci1ubmJkLW1pZ3JhdGlvbix0
-eXBlLWJ1ZyJ9CnZhciB0PShmdW5jdGlvbiBydGlpKCl7dmFyIHM9SC5OMApyZXR1cm57bjpzKCJDdyIp
-LGNSOnMoIm5CIiksdzpzKCJBeiIpLHA6cygiUVAiKSxnRjpzKCJQRDxHRCxAPiIpLGI6cygiYlE8QD4i
-KSxoOnMoImN2IikscjpzKCJYUyIpLEI6cygiZWEiKSxhUzpzKCJEMCIpLGc4OnMoIlJ6IiksYzg6cygi
-aEgiKSxZOnMoIkVIIiksZDpzKCJiODxAPiIpLEk6cygiU2ciKSxvOnMoInZRIiksZWg6cygiY1g8dUg+
-IiksUTpzKCJjWDxxVT4iKSx1OnMoImNYPEA+IiksdjpzKCJqZDxrRj4iKSxzOnMoImpkPHFVPiIpLGdO
-OnMoImpkPG42PiIpLHg6cygiamQ8QD4iKSxhOnMoImpkPElmPiIpLGQ3OnMoImpkPFNlKj4iKSxoNDpz
-KCJqZDxqOCo+IiksRzpzKCJqZDxaMDxxVSosTWgqPio+IiksY1E6cygiamQ8RDgqPiIpLGk6cygiamQ8
-cVUqPiIpLGFBOnMoImpkPHlEKj4iKSxhSjpzKCJqZDx3Yio+IiksVjpzKCJqZDxJZio+IiksZDQ6cygi
-amQ8cVU/PiIpLFQ6cygid2UiKSxlSDpzKCJ2bSIpLEQ6cygiYzUiKSxhVTpzKCJYajxAPiIpLGFtOnMo
-IlR6PEA+IiksZW86cygiTjU8R0QsQD4iKSxkejpzKCJoRiIpLEU6cygiek08cVU+IiksajpzKCJ6TTxA
-PiIpLEw6cygiek08SWY+IiksSjpzKCJaMDxxVSxxVT4iKSxmOnMoIlowPEAsQD4iKSxkbzpzKCJsSjxx
-VSxAPiIpLGZqOnMoImxKPHFVKixxVT4iKSxkRTpzKCJFVCIpLGJtOnMoIlY2IiksQTpzKCJ1SCIpLGY2
-OnMoImtGIiksUDpzKCJjOCIpLEs6cygiTWgiKSxxOnMoInRuPFpaPiIpLGZ2OnMoIndMIiksZXc6cygi
-bmQiKSxDOnMoInh1PHFVPiIpLGw6cygiR3oiKSxOOnMoInFVIiksZDA6cygicVUocVUqKSIpLGc3OnMo
-ImhpIiksZm86cygiR0QiKSxhVzpzKCJ5WSIpLGFrOnMoIkFTIiksZ2M6cygibjYiKSxiSjpzKCJrZCIp
-LGR3OnMoIkdqPHFVLHFVPiIpLGREOnMoImlEIiksZUo6cygidTY8cVU+IiksZzQ6cygiSzUiKSxjaTpz
-KCJ2NiIpLGcyOnMoIkNtIiksYkM6cygiWmY8ZkoqPiIpLGg5OnMoIkNRIiksYWM6cygiZTciKSxrOnMo
-ImV1PEFqKj4iKSxSOnMoInd6PGN2Kj4iKSxjOnMoInZzPEA+IiksZko6cygidnM8SWY+IiksZ1Y6cygi
-dnM8ZkoqPiIpLGNyOnMoIkpRIikseTpzKCJhMiIpLGFsOnMoImEyKE1oKSIpLGdSOnMoIkNQIiksejpz
-KCJAIiksZk86cygiQCgpIiksYkk6cygiQChNaCkiKSxhZzpzKCJAKE1oLEd6KSIpLGJVOnMoIkAoeHU8
-cVU+KSIpLGRPOnMoIkAocVUpIiksYjg6cygiQChALEApIiksUzpzKCJJZiIpLGRkOnMoIkdoKiIpLGc6
-cygiY3YqIiksYUw6cygiZWEqIiksYVg6cygiTEwqIiksZkU6cygiSDcqIiksVTpzKCJjWDxAPioiKSxk
-SDpzKCJFNCoiKSxmSzpzKCJ6TTxAPioiKSxkXzpzKCJ6TTxqOCo+KiIpLGRwOnMoInpNPFowPHFVKixN
-aCo+Kj4qIiksbTpzKCJ6TTxNaCo+KiIpLGF3OnMoIlowPEAsQD4qIiksdDpzKCJaMDxxVSosTWgqPioi
-KSxPOnMoIkFqKiIpLGNGOnMoIjAmKiIpLF86cygiTWgqIiksZVE6cygiZXcqIiksWDpzKCJxVSoiKSxj
-aDpzKCJEMD8iKSxiRzpzKCJiODxjOD4/IiksYms6cygiek08cVU+PyIpLGJNOnMoInpNPEA+PyIpLGNa
-OnMoIlowPHFVLHFVPj8iKSxjOTpzKCJaMDxxVSxAPj8iKSxXOnMoIk1oPyIpLEY6cygiRmU8QCxAPj8i
-KSxlOnMoImJuPyIpLGI3OnMoImEyKE1oKT8iKSxidzpzKCJAKGVhKT8iKSxmVjpzKCJNaD8oTWg/LE1o
-Pyk/IiksZEE6cygiTWg/KEApPyIpLFo6cygifigpPyIpLGViOnMoIn4oZXcqKT8iKSxkaTpzKCJaWiIp
-LEg6cygifiIpLE06cygifigpIiksZUE6cygifihxVSxxVSkiKSxjQTpzKCJ+KHFVLEApIil9fSkoKTso
-ZnVuY3Rpb24gY29uc3RhbnRzKCl7dmFyIHM9aHVua0hlbHBlcnMubWFrZUNvbnN0TGlzdApDLnhuPVcu
-R2gucHJvdG90eXBlCkMuUlk9Vy5RUC5wcm90b3R5cGUKQy5tSD1XLmFlLnByb3RvdHlwZQpDLkJaPVcu
-VmIucHJvdG90eXBlCkMuRHQ9Vy5mSi5wcm90b3R5cGUKQy5Paz1KLkd2LnByb3RvdHlwZQpDLk5tPUou
-amQucHJvdG90eXBlCkMuam49Si5iVS5wcm90b3R5cGUKQy5qTj1KLndlLnByb3RvdHlwZQpDLkNEPUou
-cUkucHJvdG90eXBlCkMueEI9Si5Eci5wcm90b3R5cGUKQy5ERz1KLmM1LnByb3RvdHlwZQpDLkV4PVcu
-dzcucHJvdG90eXBlCkMuTkE9SC5WNi5wcm90b3R5cGUKQy50NT1XLkJILnByb3RvdHlwZQpDLkx0PVcu
-U04ucHJvdG90eXBlCkMuWlE9Si5pQy5wcm90b3R5cGUKQy5JZT1XLlRiLnByb3RvdHlwZQpDLnZCPUou
-a2QucHJvdG90eXBlCkMub2w9Vy5LNS5wcm90b3R5cGUKQy55OD1uZXcgUC5VOCgpCkMuaDk9bmV3IFAu
-Q1YoKQpDLkd3PW5ldyBILkZ1KEguTjAoIkZ1PGM4PiIpKQpDLk80PWZ1bmN0aW9uIGdldFRhZ0ZhbGxi
-YWNrKG8pIHsKICB2YXIgcyA9IE9iamVjdC5wcm90b3R5cGUudG9TdHJpbmcuY2FsbChvKTsKICByZXR1
-cm4gcy5zdWJzdHJpbmcoOCwgcy5sZW5ndGggLSAxKTsKfQpDLllxPWZ1bmN0aW9uKCkgewogIHZhciB0
-b1N0cmluZ0Z1bmN0aW9uID0gT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZzsKICBmdW5jdGlvbiBnZXRU
-YWcobykgewogICAgdmFyIHMgPSB0b1N0cmluZ0Z1bmN0aW9uLmNhbGwobyk7CiAgICByZXR1cm4gcy5z
-dWJzdHJpbmcoOCwgcy5sZW5ndGggLSAxKTsKICB9CiAgZnVuY3Rpb24gZ2V0VW5rbm93blRhZyhvYmpl
-Y3QsIHRhZykgewogICAgaWYgKC9eSFRNTFtBLVpdLipFbGVtZW50JC8udGVzdCh0YWcpKSB7CiAgICAg
-IHZhciBuYW1lID0gdG9TdHJpbmdGdW5jdGlvbi5jYWxsKG9iamVjdCk7CiAgICAgIGlmIChuYW1lID09
-ICJbb2JqZWN0IE9iamVjdF0iKSByZXR1cm4gbnVsbDsKICAgICAgcmV0dXJuICJIVE1MRWxlbWVudCI7
-CiAgICB9CiAgfQogIGZ1bmN0aW9uIGdldFVua25vd25UYWdHZW5lcmljQnJvd3NlcihvYmplY3QsIHRh
-ZykgewogICAgaWYgKHNlbGYuSFRNTEVsZW1lbnQgJiYgb2JqZWN0IGluc3RhbmNlb2YgSFRNTEVsZW1l
-bnQpIHJldHVybiAiSFRNTEVsZW1lbnQiOwogICAgcmV0dXJuIGdldFVua25vd25UYWcob2JqZWN0LCB0
-YWcpOwogIH0KICBmdW5jdGlvbiBwcm90b3R5cGVGb3JUYWcodGFnKSB7CiAgICBpZiAodHlwZW9mIHdp
-bmRvdyA9PSAidW5kZWZpbmVkIikgcmV0dXJuIG51bGw7CiAgICBpZiAodHlwZW9mIHdpbmRvd1t0YWdd
-ID09ICJ1bmRlZmluZWQiKSByZXR1cm4gbnVsbDsKICAgIHZhciBjb25zdHJ1Y3RvciA9IHdpbmRvd1t0
-YWddOwogICAgaWYgKHR5cGVvZiBjb25zdHJ1Y3RvciAhPSAiZnVuY3Rpb24iKSByZXR1cm4gbnVsbDsK
-ICAgIHJldHVybiBjb25zdHJ1Y3Rvci5wcm90b3R5cGU7CiAgfQogIGZ1bmN0aW9uIGRpc2NyaW1pbmF0
-b3IodGFnKSB7IHJldHVybiBudWxsOyB9CiAgdmFyIGlzQnJvd3NlciA9IHR5cGVvZiBuYXZpZ2F0b3Ig
-PT0gIm9iamVjdCI7CiAgcmV0dXJuIHsKICAgIGdldFRhZzogZ2V0VGFnLAogICAgZ2V0VW5rbm93blRh
-ZzogaXNCcm93c2VyID8gZ2V0VW5rbm93blRhZ0dlbmVyaWNCcm93c2VyIDogZ2V0VW5rbm93blRhZywK
-ICAgIHByb3RvdHlwZUZvclRhZzogcHJvdG90eXBlRm9yVGFnLAogICAgZGlzY3JpbWluYXRvcjogZGlz
-Y3JpbWluYXRvciB9Owp9CkMud2I9ZnVuY3Rpb24oZ2V0VGFnRmFsbGJhY2spIHsKICByZXR1cm4gZnVu
-Y3Rpb24oaG9va3MpIHsKICAgIGlmICh0eXBlb2YgbmF2aWdhdG9yICE9ICJvYmplY3QiKSByZXR1cm4g
-aG9va3M7CiAgICB2YXIgdWEgPSBuYXZpZ2F0b3IudXNlckFnZW50OwogICAgaWYgKHVhLmluZGV4T2Yo
-IkR1bXBSZW5kZXJUcmVlIikgPj0gMCkgcmV0dXJuIGhvb2tzOwogICAgaWYgKHVhLmluZGV4T2YoIkNo
-cm9tZSIpID49IDApIHsKICAgICAgZnVuY3Rpb24gY29uZmlybShwKSB7CiAgICAgICAgcmV0dXJuIHR5
-cGVvZiB3aW5kb3cgPT0gIm9iamVjdCIgJiYgd2luZG93W3BdICYmIHdpbmRvd1twXS5uYW1lID09IHA7
-CiAgICAgIH0KICAgICAgaWYgKGNvbmZpcm0oIldpbmRvdyIpICYmIGNvbmZpcm0oIkhUTUxFbGVtZW50
-IikpIHJldHVybiBob29rczsKICAgIH0KICAgIGhvb2tzLmdldFRhZyA9IGdldFRhZ0ZhbGxiYWNrOwog
-IH07Cn0KQy5LVT1mdW5jdGlvbihob29rcykgewogIGlmICh0eXBlb2YgZGFydEV4cGVyaW1lbnRhbEZp
-eHVwR2V0VGFnICE9ICJmdW5jdGlvbiIpIHJldHVybiBob29rczsKICBob29rcy5nZXRUYWcgPSBkYXJ0
-RXhwZXJpbWVudGFsRml4dXBHZXRUYWcoaG9va3MuZ2V0VGFnKTsKfQpDLmZRPWZ1bmN0aW9uKGhvb2tz
-KSB7CiAgdmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcHJvdG90eXBlRm9yVGFnID0gaG9v
-a3MucHJvdG90eXBlRm9yVGFnOwogIGZ1bmN0aW9uIGdldFRhZ0ZpeGVkKG8pIHsKICAgIHZhciB0YWcg
-PSBnZXRUYWcobyk7CiAgICBpZiAodGFnID09ICJEb2N1bWVudCIpIHsKICAgICAgaWYgKCEhby54bWxW
-ZXJzaW9uKSByZXR1cm4gIiFEb2N1bWVudCI7CiAgICAgIHJldHVybiAiIUhUTUxEb2N1bWVudCI7CiAg
-ICB9CiAgICByZXR1cm4gdGFnOwogIH0KICBmdW5jdGlvbiBwcm90b3R5cGVGb3JUYWdGaXhlZCh0YWcp
-IHsKICAgIGlmICh0YWcgPT0gIkRvY3VtZW50IikgcmV0dXJuIG51bGw7CiAgICByZXR1cm4gcHJvdG90
-eXBlRm9yVGFnKHRhZyk7CiAgfQogIGhvb2tzLmdldFRhZyA9IGdldFRhZ0ZpeGVkOwogIGhvb2tzLnBy
-b3RvdHlwZUZvclRhZyA9IHByb3RvdHlwZUZvclRhZ0ZpeGVkOwp9CkMuZGs9ZnVuY3Rpb24oaG9va3Mp
-IHsKICB2YXIgdXNlckFnZW50ID0gdHlwZW9mIG5hdmlnYXRvciA9PSAib2JqZWN0IiA/IG5hdmlnYXRv
-ci51c2VyQWdlbnQgOiAiIjsKICBpZiAodXNlckFnZW50LmluZGV4T2YoIkZpcmVmb3giKSA9PSAtMSkg
-cmV0dXJuIGhvb2tzOwogIHZhciBnZXRUYWcgPSBob29rcy5nZXRUYWc7CiAgdmFyIHF1aWNrTWFwID0g
-ewogICAgIkJlZm9yZVVubG9hZEV2ZW50IjogIkV2ZW50IiwKICAgICJEYXRhVHJhbnNmZXIiOiAiQ2xp
-cGJvYXJkIiwKICAgICJHZW9HZW9sb2NhdGlvbiI6ICJHZW9sb2NhdGlvbiIsCiAgICAiTG9jYXRpb24i
-OiAiIUxvY2F0aW9uIiwKICAgICJXb3JrZXJNZXNzYWdlRXZlbnQiOiAiTWVzc2FnZUV2ZW50IiwKICAg
-ICJYTUxEb2N1bWVudCI6ICIhRG9jdW1lbnQifTsKICBmdW5jdGlvbiBnZXRUYWdGaXJlZm94KG8pIHsK
-ICAgIHZhciB0YWcgPSBnZXRUYWcobyk7CiAgICByZXR1cm4gcXVpY2tNYXBbdGFnXSB8fCB0YWc7CiAg
-fQogIGhvb2tzLmdldFRhZyA9IGdldFRhZ0ZpcmVmb3g7Cn0KQy54aT1mdW5jdGlvbihob29rcykgewog
+IlNVIjpbIklmIl19LCJ4aiI6eyJsRCI6WyJJZiJdLCJYaiI6WyJJZiJdLCJ6TSI6WyJJZiJdLCJFVCI6
+W10sImJRIjpbIklmIl0sIkFTIjpbXSwiY1giOlsiSWYiXSwiU1UiOlsiSWYiXSwibEQuRSI6IklmIn0s
+ImRFIjp7ImxEIjpbIklmIl0sIlhqIjpbIklmIl0sInpNIjpbIklmIl0sIkVUIjpbXSwiYlEiOlsiSWYi
+XSwiQVMiOltdLCJjWCI6WyJJZiJdLCJTVSI6WyJJZiJdLCJsRC5FIjoiSWYifSwiWkEiOnsibEQiOlsi
+SWYiXSwiWGoiOlsiSWYiXSwiek0iOlsiSWYiXSwiRVQiOltdLCJiUSI6WyJJZiJdLCJBUyI6W10sImNY
+IjpbIklmIl0sIlNVIjpbIklmIl0sImxELkUiOiJJZiJ9LCJkVCI6eyJsRCI6WyJJZiJdLCJYaiI6WyJJ
+ZiJdLCJ6TSI6WyJJZiJdLCJFVCI6W10sImJRIjpbIklmIl0sIkFTIjpbXSwiY1giOlsiSWYiXSwiU1Ui
+OlsiSWYiXSwibEQuRSI6IklmIn0sIlBxIjp7ImxEIjpbIklmIl0sIlhqIjpbIklmIl0sInpNIjpbIklm
+Il0sIkVUIjpbXSwiYlEiOlsiSWYiXSwiQVMiOltdLCJjWCI6WyJJZiJdLCJTVSI6WyJJZiJdLCJsRC5F
+IjoiSWYifSwiZUUiOnsibEQiOlsiSWYiXSwiWGoiOlsiSWYiXSwiek0iOlsiSWYiXSwiRVQiOltdLCJi
+USI6WyJJZiJdLCJBUyI6W10sImNYIjpbIklmIl0sIlNVIjpbIklmIl0sImxELkUiOiJJZiJ9LCJWNiI6
+eyJsRCI6WyJJZiJdLCJuNiI6W10sIlhqIjpbIklmIl0sInpNIjpbIklmIl0sIkVUIjpbXSwiYlEiOlsi
+SWYiXSwiQVMiOltdLCJjWCI6WyJJZiJdLCJTVSI6WyJJZiJdLCJsRC5FIjoiSWYifSwia1MiOnsiWFMi
+OltdfSwiaU0iOnsiWFMiOltdfSwiR1YiOnsiQW4iOlsiMSJdfSwicTQiOnsiY1giOlsiMSJdLCJjWC5F
+IjoiMSJ9LCJaZiI6eyJQZiI6WyIxIl19LCJ2cyI6eyJiOCI6WyIxIl19LCJDdyI6eyJYUyI6W119LCJt
+MCI6eyJRbSI6W119LCJKaSI6eyJtMCI6W10sIlFtIjpbXX0sImI2Ijp7ImxmIjpbIjEiXSwieHUiOlsi
+MSJdLCJiUSI6WyIxIl0sImNYIjpbIjEiXSwibGYuRSI6IjEifSwibG0iOnsiQW4iOlsiMSJdfSwibVci
+OnsiY1giOlsiMSJdfSwidXkiOnsibEQiOlsiMSJdLCJ6TSI6WyIxIl0sImJRIjpbIjEiXSwiY1giOlsi
+MSJdfSwiaWwiOnsiWWsiOlsiMSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIllrIjp7IlowIjpbIjEiLCIy
+Il19LCJQbiI6eyJaMCI6WyIxIiwiMiJdfSwiR2oiOnsiUlUiOlsiMSIsIjIiXSwiUG4iOlsiMSIsIjIi
+XSwiS1AiOlsiMSIsIjIiXSwiWjAiOlsiMSIsIjIiXX0sIlZqIjp7ImxmIjpbIjEiXSwieHUiOlsiMSJd
+LCJiUSI6WyIxIl0sImNYIjpbIjEiXX0sIlh2Ijp7ImxmIjpbIjEiXSwieHUiOlsiMSJdLCJiUSI6WyIx
+Il0sImNYIjpbIjEiXX0sInV3Ijp7IllrIjpbInFVIiwiQCJdLCJaMCI6WyJxVSIsIkAiXSwiWWsuSyI6
+InFVIiwiWWsuViI6IkAifSwiaTgiOnsiYUwiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwi
+YUwuRSI6InFVIiwiY1guRSI6InFVIn0sIkNWIjp7IlVrIjpbInpNPElmPiIsInFVIl0sIlVrLlMiOiJ6
+TTxJZj4ifSwiVTgiOnsid0kiOlsiek08SWY+IiwicVUiXX0sIlppIjp7IlVrIjpbInFVIiwiek08SWY+
+Il19LCJVZCI6eyJYUyI6W119LCJLOCI6eyJYUyI6W119LCJieSI6eyJVayI6WyJNaD8iLCJxVSJdLCJV
+ay5TIjoiTWg/In0sIm9qIjp7IndJIjpbIk1oPyIsInFVIl19LCJNeCI6eyJ3SSI6WyJxVSIsIk1oPyJd
+fSwidTUiOnsiVWsiOlsicVUiLCJ6TTxJZj4iXSwiVWsuUyI6InFVIn0sIkUzIjp7IndJIjpbInFVIiwi
+ek08SWY+Il19LCJHWSI6eyJ3SSI6WyJ6TTxJZj4iLCJxVSJdfSwiQ1AiOnsiWloiOltdfSwiSWYiOnsi
+WloiOltdfSwiek0iOnsiYlEiOlsiMSJdLCJjWCI6WyIxIl19LCJpYiI6eyJPZCI6W119LCJ4dSI6eyJi
+USI6WyIxIl0sImNYIjpbIjEiXX0sInFVIjp7InZYIjpbXX0sIkM2Ijp7IlhTIjpbXX0sIkV6Ijp7IlhT
+IjpbXX0sIkYiOnsiWFMiOltdfSwidSI6eyJYUyI6W119LCJiSiI6eyJYUyI6W119LCJlWSI6eyJYUyI6
+W119LCJtcCI6eyJYUyI6W119LCJ1YiI6eyJYUyI6W119LCJkcyI6eyJYUyI6W119LCJsaiI6eyJYUyI6
+W119LCJVViI6eyJYUyI6W119LCJrNSI6eyJYUyI6W119LCJLWSI6eyJYUyI6W119LCJjIjp7IlhTIjpb
+XX0sIkNEIjp7IlJ6IjpbXX0sImFFIjp7IlJ6IjpbXX0sIlpkIjp7Ikd6IjpbXX0sIlJuIjp7IkJMIjpb
+XX0sIkRuIjp7ImlEIjpbXX0sIlVmIjp7ImlEIjpbXX0sInFlIjp7ImlEIjpbXX0sInFFIjp7ImN2Ijpb
+XSwidUgiOltdLCJEMCI6W119LCJHaCI6eyJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwiZlkiOnsiY3Yi
+OltdLCJ1SCI6W10sIkQwIjpbXX0sIm5CIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJRUCI6eyJj
+diI6W10sInVIIjpbXSwiRDAiOltdfSwibngiOnsidUgiOltdLCJEMCI6W119LCJRRiI6eyJ1SCI6W10s
+IkQwIjpbXX0sIklCIjp7InRuIjpbIlpaIl19LCJ3eiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEi
+OlsiMSJdLCJjWCI6WyIxIl0sImxELkUiOiIxIn0sImN2Ijp7InVIIjpbXSwiRDAiOltdfSwiaEgiOnsi
+QXoiOltdfSwiaDQiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sIlZiIjp7InVIIjpbXSwiRDAiOltd
+fSwiZkoiOnsiRDAiOltdfSwid2EiOnsiRDAiOltdfSwiQWoiOnsiZWEiOltdfSwiZTciOnsibEQiOlsi
+dUgiXSwiek0iOlsidUgiXSwiYlEiOlsidUgiXSwiY1giOlsidUgiXSwibEQuRSI6InVIIn0sInVIIjp7
+IkQwIjpbXX0sIkJIIjp7ImxEIjpbInVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVI
+Il0sImJRIjpbInVIIl0sImNYIjpbInVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJTTiI6eyJj
+diI6W10sInVIIjpbXSwiRDAiOltdfSwiZXciOnsiZWEiOltdfSwibHAiOnsiY3YiOltdLCJ1SCI6W10s
+IkQwIjpbXX0sIlRiIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJJdiI6eyJjdiI6W10sInVIIjpb
+XSwiRDAiOltdfSwiV1AiOnsiY3YiOltdLCJ1SCI6W10sIkQwIjpbXX0sInlZIjp7ImN2IjpbXSwidUgi
+OltdLCJEMCI6W119LCJ3NiI6eyJlYSI6W119LCJLNSI6eyJ2NiI6W10sIkQwIjpbXX0sIkNtIjp7IkQw
+IjpbXX0sIkNRIjp7InVIIjpbXSwiRDAiOltdfSwidzQiOnsidG4iOlsiWloiXX0sInJoIjp7ImxEIjpb
+InVIIl0sIkdtIjpbInVIIl0sInpNIjpbInVIIl0sIlhqIjpbInVIIl0sImJRIjpbInVIIl0sImNYIjpb
+InVIIl0sImxELkUiOiJ1SCIsIkdtLkUiOiJ1SCJ9LCJjZiI6eyJZayI6WyJxVSIsInFVIl0sIlowIjpb
+InFVIiwicVUiXX0sImk3Ijp7IllrIjpbInFVIiwicVUiXSwiWjAiOlsicVUiLCJxVSJdLCJZay5LIjoi
+cVUiLCJZay5WIjoicVUifSwiU3kiOnsiWWsiOlsicVUiLCJxVSJdLCJaMCI6WyJxVSIsInFVIl0sIllr
+LksiOiJxVSIsIllrLlYiOiJxVSJ9LCJJNCI6eyJsZiI6WyJxVSJdLCJ4dSI6WyJxVSJdLCJiUSI6WyJx
+VSJdLCJjWCI6WyJxVSJdLCJsZi5FIjoicVUifSwiUk8iOnsicWgiOlsiMSJdfSwiZXUiOnsiUk8iOlsi
+MSJdLCJxaCI6WyIxIl19LCJ4QyI6eyJNTyI6WyIxIl19LCJKUSI6eyJrRiI6W119LCJ2RCI6eyJrRiI6
+W119LCJtNiI6eyJrRiI6W119LCJjdCI6eyJrRiI6W119LCJPdyI6eyJrRiI6W119LCJXOSI6eyJBbiI6
+WyIxIl19LCJkVyI6eyJ2NiI6W10sIkQwIjpbXX0sIm1rIjp7InkwIjpbXX0sIktvIjp7Im9uIjpbXX0s
+IkFzIjp7ImxmIjpbInFVIl0sInh1IjpbInFVIl0sImJRIjpbInFVIl0sImNYIjpbInFVIl19LCJyNyI6
+eyJFNCI6W119LCJUeiI6eyJsRCI6WyIxIl0sInpNIjpbIjEiXSwiYlEiOlsiMSJdLCJFNCI6W10sImNY
+IjpbIjEiXSwibEQuRSI6IjEifSwibmQiOnsiaGkiOltdLCJjdiI6W10sInVIIjpbXSwiRDAiOltdfSwi
+S2UiOnsibGYiOlsicVUiXSwieHUiOlsicVUiXSwiYlEiOlsicVUiXSwiY1giOlsicVUiXSwibGYuRSI6
+InFVIn0sImhpIjp7ImN2IjpbXSwidUgiOltdLCJEMCI6W119LCJYQSI6eyJrRiI6W119LCJ2dCI6eyJE
+OCI6W119LCJjRCI6eyJEOCI6W119LCJkdiI6eyJSeiI6W119LCJPRiI6eyJmdiI6W119LCJydSI6eyJm
+diI6W119LCJJViI6eyJmdiI6W119LCJuNiI6eyJ6TSI6WyJJZiJdLCJiUSI6WyJJZiJdLCJjWCI6WyJJ
+ZiJdLCJBUyI6W119fScpKQpILkZGKHYudHlwZVVuaXZlcnNlLEpTT04ucGFyc2UoJ3sidzIiOjEsIlFD
+IjoyLCJMWiI6MSwia1QiOjIsIm1XIjoxLCJ1eSI6MSwiaWwiOjIsIlZqIjoxLCJYdiI6MSwiblkiOjEs
+IldZIjoxLCJwUiI6MSwiY28iOjF9JykpCnZhciB1PXtsOiJDYW5ub3QgZXh0cmFjdCBhIGZpbGUgcGF0
+aCBmcm9tIGEgVVJJIHdpdGggYSBmcmFnbWVudCBjb21wb25lbnQiLGk6IkNhbm5vdCBleHRyYWN0IGEg
+ZmlsZSBwYXRoIGZyb20gYSBVUkkgd2l0aCBhIHF1ZXJ5IGNvbXBvbmVudCIsajoiQ2Fubm90IGV4dHJh
+Y3QgYSBub24tV2luZG93cyBmaWxlIHBhdGggZnJvbSBhIGZpbGUgVVJJIHdpdGggYW4gYXV0aG9yaXR5
+IixnOiJgbnVsbGAgZW5jb3VudGVyZWQgYXMgdGhlIHJlc3VsdCBmcm9tIGV4cHJlc3Npb24gd2l0aCB0
+eXBlIGBOZXZlcmAuIixkOiJhcmVhLWFuYWx5emVyLGFuYWx5emVyLW5uYmQtbWlncmF0aW9uLHR5cGUt
+YnVnIn0KdmFyIHQ9KGZ1bmN0aW9uIHJ0aWkoKXt2YXIgcz1ILk4wCnJldHVybntuOnMoIkN3IiksY1I6
+cygibkIiKSx3OnMoIkF6IikscDpzKCJRUCIpLGdGOnMoIlBEPEdELEA+IiksZDpzKCJiUTxAPiIpLGg6
+cygiY3YiKSxyOnMoIlhTIiksQjpzKCJlYSIpLGFTOnMoIkQwIiksZzg6cygiUnoiKSxjODpzKCJoSCIp
+LFk6cygiRUgiKSxlOnMoImI4PEA+IiksSTpzKCJTZyIpLG86cygidlEiKSxlaDpzKCJjWDx1SD4iKSxR
+OnMoImNYPHFVPiIpLHU6cygiY1g8QD4iKSx2OnMoImpkPGtGPiIpLHM6cygiamQ8cVU+IiksZ046cygi
+amQ8bjY+IiksYjpzKCJqZDxAPiIpLGE6cygiamQ8SWY+IiksZDc6cygiamQ8U2UqPiIpLGg0OnMoImpk
+PGo4Kj4iKSxHOnMoImpkPFowPHFVKixNaCo+Kj4iKSxjUTpzKCJqZDxEOCo+IiksaTpzKCJqZDxxVSo+
+IiksYUE6cygiamQ8eUQqPiIpLGFKOnMoImpkPHdiKj4iKSxWOnMoImpkPElmKj4iKSxkNDpzKCJqZDxx
+VT8+IiksVDpzKCJ3ZSIpLGVIOnMoInZtIikseDpzKCJjNSIpLGFVOnMoIlhqPEA+IiksYW06cygiVHo8
+QD4iKSxlbzpzKCJONTxHRCxAPiIpLGR6OnMoImhGIiksRDpzKCJ6TTxxVT4iKSxqOnMoInpNPEA+Iiks
+TDpzKCJ6TTxJZj4iKSxKOnMoIlowPHFVLHFVPiIpLGY6cygiWjA8QCxAPiIpLGRvOnMoImxKPHFVLEA+
+IiksZmo6cygibEo8cVUqLHFVPiIpLGRFOnMoIkVUIiksYm06cygiVjYiKSxBOnMoInVIIiksRTpzKCJr
+RiIpLFA6cygiYzgiKSxLOnMoIk1oIikscTpzKCJ0bjxaWj4iKSxmdjpzKCJ3TCIpLGV3OnMoIm5kIiks
+QzpzKCJ4dTxxVT4iKSxsOnMoIkd6IiksTjpzKCJxVSIpLGQwOnMoInFVKHFVKikiKSxnNzpzKCJoaSIp
+LGZvOnMoIkdEIiksYVc6cygieVkiKSxhazpzKCJBUyIpLGdjOnMoIm42IiksYko6cygia2QiKSxkdzpz
+KCJHajxxVSxxVT4iKSxkRDpzKCJpRCIpLGVKOnMoInU2PHFVPiIpLGc0OnMoIks1IiksY2k6cygidjYi
+KSxnMjpzKCJDbSIpLGJDOnMoIlpmPGZKKj4iKSxoOTpzKCJDUSIpLGFjOnMoImU3IiksazpzKCJldTxB
+aio+IiksUjpzKCJ3ejxjdio+IiksYzpzKCJ2czxAPiIpLGZKOnMoInZzPElmPiIpLGdWOnMoInZzPGZK
+Kj4iKSxjcjpzKCJKUSIpLHk6cygiYTIiKSxhbDpzKCJhMihNaCkiKSxnUjpzKCJDUCIpLHo6cygiQCIp
+LGZPOnMoIkAoKSIpLGJJOnMoIkAoTWgpIiksYWc6cygiQChNaCxHeikiKSxiVTpzKCJAKHh1PHFVPiki
+KSxkTzpzKCJAKHFVKSIpLGI4OnMoIkAoQCxAKSIpLFM6cygiSWYiKSxkZDpzKCJHaCoiKSxnOnMoImN2
+KiIpLGFMOnMoImVhKiIpLGFYOnMoIkxMKiIpLGZFOnMoIkg3KiIpLFU6cygiY1g8QD4qIiksZEg6cygi
+RTQqIiksZks6cygiek08QD4qIiksZF86cygiek08ajgqPioiKSxkcDpzKCJ6TTxaMDxxVSosTWgqPio+
+KiIpLGVFOnMoInpNPE1oKj4qIiksYXc6cygiWjA8QCxAPioiKSx0OnMoIlowPHFVKixNaCo+KiIpLE86
+cygiQWoqIiksY0Y6cygiMCYqIiksXzpzKCJNaCoiKSxlUTpzKCJldyoiKSxYOnMoInFVKiIpLGNoOnMo
+IkQwPyIpLGJHOnMoImI4PGM4Pj8iKSxiazpzKCJ6TTxxVT4/IiksYk06cygiek08QD4/IiksY1o6cygi
+WjA8cVUscVU+PyIpLGM5OnMoIlowPHFVLEA+PyIpLFc6cygiTWg/IiksRjpzKCJGZTxALEA+PyIpLG06
+cygiYm4/IiksYjc6cygiYTIoTWgpPyIpLGJ3OnMoIkAoZWEpPyIpLGZWOnMoIk1oPyhNaD8sTWg/KT8i
+KSxkQTpzKCJNaD8oQCk/IiksWjpzKCJ+KCk/IiksZWI6cygifihldyopPyIpLGRpOnMoIlpaIiksSDpz
+KCJ+IiksTTpzKCJ+KCkiKSxlQTpzKCJ+KHFVLHFVKSIpLGNBOnMoIn4ocVUsQCkiKX19KSgpOyhmdW5j
+dGlvbiBjb25zdGFudHMoKXt2YXIgcz1odW5rSGVscGVycy5tYWtlQ29uc3RMaXN0CkMueG49Vy5HaC5w
+cm90b3R5cGUKQy5SWT1XLlFQLnByb3RvdHlwZQpDLm1IPVcuYWUucHJvdG90eXBlCkMuQlo9Vy5WYi5w
+cm90b3R5cGUKQy5EdD1XLmZKLnByb3RvdHlwZQpDLk9rPUouR3YucHJvdG90eXBlCkMuTm09Si5qZC5w
+cm90b3R5cGUKQy5qbj1KLmJVLnByb3RvdHlwZQpDLmpOPUoud2UucHJvdG90eXBlCkMuQ0Q9Si5xSS5w
+cm90b3R5cGUKQy54Qj1KLkRyLnByb3RvdHlwZQpDLkRHPUouYzUucHJvdG90eXBlCkMuRXg9Vy53Ny5w
+cm90b3R5cGUKQy5OQT1ILlY2LnByb3RvdHlwZQpDLnQ1PVcuQkgucHJvdG90eXBlCkMuTHQ9Vy5TTi5w
+cm90b3R5cGUKQy5aUT1KLmlDLnByb3RvdHlwZQpDLkllPVcuVGIucHJvdG90eXBlCkMudkI9Si5rZC5w
+cm90b3R5cGUKQy5vbD1XLks1LnByb3RvdHlwZQpDLnk4PW5ldyBQLlU4KCkKQy5oOT1uZXcgUC5DVigp
+CkMuR3c9bmV3IEguRnUoSC5OMCgiRnU8Yzg+IikpCkMuTzQ9ZnVuY3Rpb24gZ2V0VGFnRmFsbGJhY2so
+bykgewogIHZhciBzID0gT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKG8pOwogIHJldHVybiBz
+LnN1YnN0cmluZyg4LCBzLmxlbmd0aCAtIDEpOwp9CkMuWXE9ZnVuY3Rpb24oKSB7CiAgdmFyIHRvU3Ry
+aW5nRnVuY3Rpb24gPSBPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nOwogIGZ1bmN0aW9uIGdldFRhZyhv
+KSB7CiAgICB2YXIgcyA9IHRvU3RyaW5nRnVuY3Rpb24uY2FsbChvKTsKICAgIHJldHVybiBzLnN1YnN0
+cmluZyg4LCBzLmxlbmd0aCAtIDEpOwogIH0KICBmdW5jdGlvbiBnZXRVbmtub3duVGFnKG9iamVjdCwg
+dGFnKSB7CiAgICBpZiAoL15IVE1MW0EtWl0uKkVsZW1lbnQkLy50ZXN0KHRhZykpIHsKICAgICAgdmFy
+IG5hbWUgPSB0b1N0cmluZ0Z1bmN0aW9uLmNhbGwob2JqZWN0KTsKICAgICAgaWYgKG5hbWUgPT0gIltv
+YmplY3QgT2JqZWN0XSIpIHJldHVybiBudWxsOwogICAgICByZXR1cm4gIkhUTUxFbGVtZW50IjsKICAg
+IH0KICB9CiAgZnVuY3Rpb24gZ2V0VW5rbm93blRhZ0dlbmVyaWNCcm93c2VyKG9iamVjdCwgdGFnKSB7
+CiAgICBpZiAoc2VsZi5IVE1MRWxlbWVudCAmJiBvYmplY3QgaW5zdGFuY2VvZiBIVE1MRWxlbWVudCkg
+cmV0dXJuICJIVE1MRWxlbWVudCI7CiAgICByZXR1cm4gZ2V0VW5rbm93blRhZyhvYmplY3QsIHRhZyk7
+CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZyh0YWcpIHsKICAgIGlmICh0eXBlb2Ygd2luZG93
+ID09ICJ1bmRlZmluZWQiKSByZXR1cm4gbnVsbDsKICAgIGlmICh0eXBlb2Ygd2luZG93W3RhZ10gPT0g
+InVuZGVmaW5lZCIpIHJldHVybiBudWxsOwogICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107
+CiAgICBpZiAodHlwZW9mIGNvbnN0cnVjdG9yICE9ICJmdW5jdGlvbiIpIHJldHVybiBudWxsOwogICAg
+cmV0dXJuIGNvbnN0cnVjdG9yLnByb3RvdHlwZTsKICB9CiAgZnVuY3Rpb24gZGlzY3JpbWluYXRvcih0
+YWcpIHsgcmV0dXJuIG51bGw7IH0KICB2YXIgaXNCcm93c2VyID0gdHlwZW9mIG5hdmlnYXRvciA9PSAi
+b2JqZWN0IjsKICByZXR1cm4gewogICAgZ2V0VGFnOiBnZXRUYWcsCiAgICBnZXRVbmtub3duVGFnOiBp
+c0Jyb3dzZXIgPyBnZXRVbmtub3duVGFnR2VuZXJpY0Jyb3dzZXIgOiBnZXRVbmtub3duVGFnLAogICAg
+cHJvdG90eXBlRm9yVGFnOiBwcm90b3R5cGVGb3JUYWcsCiAgICBkaXNjcmltaW5hdG9yOiBkaXNjcmlt
+aW5hdG9yIH07Cn0KQy53Yj1mdW5jdGlvbihnZXRUYWdGYWxsYmFjaykgewogIHJldHVybiBmdW5jdGlv
+bihob29rcykgewogICAgaWYgKHR5cGVvZiBuYXZpZ2F0b3IgIT0gIm9iamVjdCIpIHJldHVybiBob29r
+czsKICAgIHZhciB1YSA9IG5hdmlnYXRvci51c2VyQWdlbnQ7CiAgICBpZiAodWEuaW5kZXhPZigiRHVt
+cFJlbmRlclRyZWUiKSA+PSAwKSByZXR1cm4gaG9va3M7CiAgICBpZiAodWEuaW5kZXhPZigiQ2hyb21l
+IikgPj0gMCkgewogICAgICBmdW5jdGlvbiBjb25maXJtKHApIHsKICAgICAgICByZXR1cm4gdHlwZW9m
+IHdpbmRvdyA9PSAib2JqZWN0IiAmJiB3aW5kb3dbcF0gJiYgd2luZG93W3BdLm5hbWUgPT0gcDsKICAg
+ICAgfQogICAgICBpZiAoY29uZmlybSgiV2luZG93IikgJiYgY29uZmlybSgiSFRNTEVsZW1lbnQiKSkg
+cmV0dXJuIGhvb2tzOwogICAgfQogICAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRmFsbGJhY2s7CiAgfTsK
+fQpDLktVPWZ1bmN0aW9uKGhvb2tzKSB7CiAgaWYgKHR5cGVvZiBkYXJ0RXhwZXJpbWVudGFsRml4dXBH
+ZXRUYWcgIT0gImZ1bmN0aW9uIikgcmV0dXJuIGhvb2tzOwogIGhvb2tzLmdldFRhZyA9IGRhcnRFeHBl
+cmltZW50YWxGaXh1cEdldFRhZyhob29rcy5nZXRUYWcpOwp9CkMuZlE9ZnVuY3Rpb24oaG9va3MpIHsK
+ICB2YXIgZ2V0VGFnID0gaG9va3MuZ2V0VGFnOwogIHZhciBwcm90b3R5cGVGb3JUYWcgPSBob29rcy5w
+cm90b3R5cGVGb3JUYWc7CiAgZnVuY3Rpb24gZ2V0VGFnRml4ZWQobykgewogICAgdmFyIHRhZyA9IGdl
+dFRhZyhvKTsKICAgIGlmICh0YWcgPT0gIkRvY3VtZW50IikgewogICAgICBpZiAoISFvLnhtbFZlcnNp
+b24pIHJldHVybiAiIURvY3VtZW50IjsKICAgICAgcmV0dXJuICIhSFRNTERvY3VtZW50IjsKICAgIH0K
+ICAgIHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRhZ0ZpeGVkKHRhZykgewog
+ICAgaWYgKHRhZyA9PSAiRG9jdW1lbnQiKSByZXR1cm4gbnVsbDsKICAgIHJldHVybiBwcm90b3R5cGVG
+b3JUYWcodGFnKTsKICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnRml4ZWQ7CiAgaG9va3MucHJvdG90
+eXBlRm9yVGFnID0gcHJvdG90eXBlRm9yVGFnRml4ZWQ7Cn0KQy5kaz1mdW5jdGlvbihob29rcykgewog
 IHZhciB1c2VyQWdlbnQgPSB0eXBlb2YgbmF2aWdhdG9yID09ICJvYmplY3QiID8gbmF2aWdhdG9yLnVz
-ZXJBZ2VudCA6ICIiOwogIGlmICh1c2VyQWdlbnQuaW5kZXhPZigiVHJpZGVudC8iKSA9PSAtMSkgcmV0
-dXJuIGhvb2tzOwogIHZhciBnZXRUYWcgPSBob29rcy5nZXRUYWc7CiAgdmFyIHF1aWNrTWFwID0gewog
-ICAgIkJlZm9yZVVubG9hZEV2ZW50IjogIkV2ZW50IiwKICAgICJEYXRhVHJhbnNmZXIiOiAiQ2xpcGJv
-YXJkIiwKICAgICJIVE1MRERFbGVtZW50IjogIkhUTUxFbGVtZW50IiwKICAgICJIVE1MRFRFbGVtZW50
-IjogIkhUTUxFbGVtZW50IiwKICAgICJIVE1MUGhyYXNlRWxlbWVudCI6ICJIVE1MRWxlbWVudCIsCiAg
-ICAiUG9zaXRpb24iOiAiR2VvcG9zaXRpb24iCiAgfTsKICBmdW5jdGlvbiBnZXRUYWdJRShvKSB7CiAg
-ICB2YXIgdGFnID0gZ2V0VGFnKG8pOwogICAgdmFyIG5ld1RhZyA9IHF1aWNrTWFwW3RhZ107CiAgICBp
-ZiAobmV3VGFnKSByZXR1cm4gbmV3VGFnOwogICAgaWYgKHRhZyA9PSAiT2JqZWN0IikgewogICAgICBp
-ZiAod2luZG93LkRhdGFWaWV3ICYmIChvIGluc3RhbmNlb2Ygd2luZG93LkRhdGFWaWV3KSkgcmV0dXJu
-ICJEYXRhVmlldyI7CiAgICB9CiAgICByZXR1cm4gdGFnOwogIH0KICBmdW5jdGlvbiBwcm90b3R5cGVG
-b3JUYWdJRSh0YWcpIHsKICAgIHZhciBjb25zdHJ1Y3RvciA9IHdpbmRvd1t0YWddOwogICAgaWYgKGNv
-bnN0cnVjdG9yID09IG51bGwpIHJldHVybiBudWxsOwogICAgcmV0dXJuIGNvbnN0cnVjdG9yLnByb3Rv
-dHlwZTsKICB9CiAgaG9va3MuZ2V0VGFnID0gZ2V0VGFnSUU7CiAgaG9va3MucHJvdG90eXBlRm9yVGFn
-ID0gcHJvdG90eXBlRm9yVGFnSUU7Cn0KQy5pNz1mdW5jdGlvbihob29rcykgeyByZXR1cm4gaG9va3M7
-IH0KCkMuQ3Q9bmV3IFAuYnkoKQpDLkVxPW5ldyBQLms1KCkKQy54TT1uZXcgUC51NSgpCkMuUWs9bmV3
-IFAuRTMoKQpDLk52PW5ldyBILmtyKCkKQy5OVT1uZXcgUC5KaSgpCkMucGQ9bmV3IFAuWmQoKQpDLkFk
-PW5ldyBNLkg3KDAsIkhpbnRBY3Rpb25LaW5kLmFkZE51bGxhYmxlSGludCIpCkMubmU9bmV3IE0uSDco
-MSwiSGludEFjdGlvbktpbmQuYWRkTm9uTnVsbGFibGVIaW50IikKQy5teT1uZXcgTS5INygyLCJIaW50
-QWN0aW9uS2luZC5jaGFuZ2VUb051bGxhYmxlSGludCIpCkMucng9bmV3IE0uSDcoMywiSGludEFjdGlv
-bktpbmQuY2hhbmdlVG9Ob25OdWxsYWJsZUhpbnQiKQpDLndWPW5ldyBNLkg3KDQsIkhpbnRBY3Rpb25L
-aW5kLnJlbW92ZU51bGxhYmxlSGludCIpCkMuZlI9bmV3IE0uSDcoNSwiSGludEFjdGlvbktpbmQucmVt
-b3ZlTm9uTnVsbGFibGVIaW50IikKQy5BMz1uZXcgUC5NeChudWxsKQpDLm5YPW5ldyBQLm9qKG51bGwp
-CkMuY3c9bmV3IEwuR2IoMCwiVW5pdE1pZ3JhdGlvblN0YXR1cy5hbHJlYWR5TWlncmF0ZWQiKQpDLmRj
-PW5ldyBMLkdiKDEsIlVuaXRNaWdyYXRpb25TdGF0dXMuaW5kZXRlcm1pbmF0ZSIpCkMuV0Q9bmV3IEwu
-R2IoMiwiVW5pdE1pZ3JhdGlvblN0YXR1cy5taWdyYXRpbmciKQpDLlhqPW5ldyBMLkdiKDMsIlVuaXRN
-aWdyYXRpb25TdGF0dXMub3B0aW5nT3V0IikKQy5sMD1ILlZNKHMoW0MuY3csQy5kYyxDLldELEMuWGpd
-KSxILk4wKCJqZDxHYio+IikpCkMuYWs9SC5WTShzKFswLDAsMzI3NzYsMzM3OTIsMSwxMDI0MCwwLDBd
-KSx0LlYpCkMuY209SC5WTShzKFsiKjo6Y2xhc3MiLCIqOjpkaXIiLCIqOjpkcmFnZ2FibGUiLCIqOjpo
-aWRkZW4iLCIqOjppZCIsIio6OmluZXJ0IiwiKjo6aXRlbXByb3AiLCIqOjppdGVtcmVmIiwiKjo6aXRl
-bXNjb3BlIiwiKjo6bGFuZyIsIio6OnNwZWxsY2hlY2siLCIqOjp0aXRsZSIsIio6OnRyYW5zbGF0ZSIs
-IkE6OmFjY2Vzc2tleSIsIkE6OmNvb3JkcyIsIkE6OmhyZWZsYW5nIiwiQTo6bmFtZSIsIkE6OnNoYXBl
-IiwiQTo6dGFiaW5kZXgiLCJBOjp0YXJnZXQiLCJBOjp0eXBlIiwiQVJFQTo6YWNjZXNza2V5IiwiQVJF
-QTo6YWx0IiwiQVJFQTo6Y29vcmRzIiwiQVJFQTo6bm9ocmVmIiwiQVJFQTo6c2hhcGUiLCJBUkVBOjp0
-YWJpbmRleCIsIkFSRUE6OnRhcmdldCIsIkFVRElPOjpjb250cm9scyIsIkFVRElPOjpsb29wIiwiQVVE
-SU86Om1lZGlhZ3JvdXAiLCJBVURJTzo6bXV0ZWQiLCJBVURJTzo6cHJlbG9hZCIsIkJETzo6ZGlyIiwi
-Qk9EWTo6YWxpbmsiLCJCT0RZOjpiZ2NvbG9yIiwiQk9EWTo6bGluayIsIkJPRFk6OnRleHQiLCJCT0RZ
-Ojp2bGluayIsIkJSOjpjbGVhciIsIkJVVFRPTjo6YWNjZXNza2V5IiwiQlVUVE9OOjpkaXNhYmxlZCIs
-IkJVVFRPTjo6bmFtZSIsIkJVVFRPTjo6dGFiaW5kZXgiLCJCVVRUT046OnR5cGUiLCJCVVRUT046OnZh
-bHVlIiwiQ0FOVkFTOjpoZWlnaHQiLCJDQU5WQVM6OndpZHRoIiwiQ0FQVElPTjo6YWxpZ24iLCJDT0w6
-OmFsaWduIiwiQ09MOjpjaGFyIiwiQ09MOjpjaGFyb2ZmIiwiQ09MOjpzcGFuIiwiQ09MOjp2YWxpZ24i
-LCJDT0w6OndpZHRoIiwiQ09MR1JPVVA6OmFsaWduIiwiQ09MR1JPVVA6OmNoYXIiLCJDT0xHUk9VUDo6
-Y2hhcm9mZiIsIkNPTEdST1VQOjpzcGFuIiwiQ09MR1JPVVA6OnZhbGlnbiIsIkNPTEdST1VQOjp3aWR0
-aCIsIkNPTU1BTkQ6OmNoZWNrZWQiLCJDT01NQU5EOjpjb21tYW5kIiwiQ09NTUFORDo6ZGlzYWJsZWQi
-LCJDT01NQU5EOjpsYWJlbCIsIkNPTU1BTkQ6OnJhZGlvZ3JvdXAiLCJDT01NQU5EOjp0eXBlIiwiREFU
-QTo6dmFsdWUiLCJERUw6OmRhdGV0aW1lIiwiREVUQUlMUzo6b3BlbiIsIkRJUjo6Y29tcGFjdCIsIkRJ
-Vjo6YWxpZ24iLCJETDo6Y29tcGFjdCIsIkZJRUxEU0VUOjpkaXNhYmxlZCIsIkZPTlQ6OmNvbG9yIiwi
-Rk9OVDo6ZmFjZSIsIkZPTlQ6OnNpemUiLCJGT1JNOjphY2NlcHQiLCJGT1JNOjphdXRvY29tcGxldGUi
-LCJGT1JNOjplbmN0eXBlIiwiRk9STTo6bWV0aG9kIiwiRk9STTo6bmFtZSIsIkZPUk06Om5vdmFsaWRh
-dGUiLCJGT1JNOjp0YXJnZXQiLCJGUkFNRTo6bmFtZSIsIkgxOjphbGlnbiIsIkgyOjphbGlnbiIsIkgz
-OjphbGlnbiIsIkg0OjphbGlnbiIsIkg1OjphbGlnbiIsIkg2OjphbGlnbiIsIkhSOjphbGlnbiIsIkhS
-Ojpub3NoYWRlIiwiSFI6OnNpemUiLCJIUjo6d2lkdGgiLCJIVE1MOjp2ZXJzaW9uIiwiSUZSQU1FOjph
-bGlnbiIsIklGUkFNRTo6ZnJhbWVib3JkZXIiLCJJRlJBTUU6OmhlaWdodCIsIklGUkFNRTo6bWFyZ2lu
-aGVpZ2h0IiwiSUZSQU1FOjptYXJnaW53aWR0aCIsIklGUkFNRTo6d2lkdGgiLCJJTUc6OmFsaWduIiwi
-SU1HOjphbHQiLCJJTUc6OmJvcmRlciIsIklNRzo6aGVpZ2h0IiwiSU1HOjpoc3BhY2UiLCJJTUc6Omlz
-bWFwIiwiSU1HOjpuYW1lIiwiSU1HOjp1c2VtYXAiLCJJTUc6OnZzcGFjZSIsIklNRzo6d2lkdGgiLCJJ
-TlBVVDo6YWNjZXB0IiwiSU5QVVQ6OmFjY2Vzc2tleSIsIklOUFVUOjphbGlnbiIsIklOUFVUOjphbHQi
-LCJJTlBVVDo6YXV0b2NvbXBsZXRlIiwiSU5QVVQ6OmF1dG9mb2N1cyIsIklOUFVUOjpjaGVja2VkIiwi
-SU5QVVQ6OmRpc2FibGVkIiwiSU5QVVQ6OmlucHV0bW9kZSIsIklOUFVUOjppc21hcCIsIklOUFVUOjps
-aXN0IiwiSU5QVVQ6Om1heCIsIklOUFVUOjptYXhsZW5ndGgiLCJJTlBVVDo6bWluIiwiSU5QVVQ6Om11
-bHRpcGxlIiwiSU5QVVQ6Om5hbWUiLCJJTlBVVDo6cGxhY2Vob2xkZXIiLCJJTlBVVDo6cmVhZG9ubHki
-LCJJTlBVVDo6cmVxdWlyZWQiLCJJTlBVVDo6c2l6ZSIsIklOUFVUOjpzdGVwIiwiSU5QVVQ6OnRhYmlu
-ZGV4IiwiSU5QVVQ6OnR5cGUiLCJJTlBVVDo6dXNlbWFwIiwiSU5QVVQ6OnZhbHVlIiwiSU5TOjpkYXRl
-dGltZSIsIktFWUdFTjo6ZGlzYWJsZWQiLCJLRVlHRU46OmtleXR5cGUiLCJLRVlHRU46Om5hbWUiLCJM
-QUJFTDo6YWNjZXNza2V5IiwiTEFCRUw6OmZvciIsIkxFR0VORDo6YWNjZXNza2V5IiwiTEVHRU5EOjph
-bGlnbiIsIkxJOjp0eXBlIiwiTEk6OnZhbHVlIiwiTElOSzo6c2l6ZXMiLCJNQVA6Om5hbWUiLCJNRU5V
-Ojpjb21wYWN0IiwiTUVOVTo6bGFiZWwiLCJNRU5VOjp0eXBlIiwiTUVURVI6OmhpZ2giLCJNRVRFUjo6
-bG93IiwiTUVURVI6Om1heCIsIk1FVEVSOjptaW4iLCJNRVRFUjo6dmFsdWUiLCJPQkpFQ1Q6OnR5cGVt
-dXN0bWF0Y2giLCJPTDo6Y29tcGFjdCIsIk9MOjpyZXZlcnNlZCIsIk9MOjpzdGFydCIsIk9MOjp0eXBl
-IiwiT1BUR1JPVVA6OmRpc2FibGVkIiwiT1BUR1JPVVA6OmxhYmVsIiwiT1BUSU9OOjpkaXNhYmxlZCIs
-Ik9QVElPTjo6bGFiZWwiLCJPUFRJT046OnNlbGVjdGVkIiwiT1BUSU9OOjp2YWx1ZSIsIk9VVFBVVDo6
-Zm9yIiwiT1VUUFVUOjpuYW1lIiwiUDo6YWxpZ24iLCJQUkU6OndpZHRoIiwiUFJPR1JFU1M6Om1heCIs
-IlBST0dSRVNTOjptaW4iLCJQUk9HUkVTUzo6dmFsdWUiLCJTRUxFQ1Q6OmF1dG9jb21wbGV0ZSIsIlNF
-TEVDVDo6ZGlzYWJsZWQiLCJTRUxFQ1Q6Om11bHRpcGxlIiwiU0VMRUNUOjpuYW1lIiwiU0VMRUNUOjpy
-ZXF1aXJlZCIsIlNFTEVDVDo6c2l6ZSIsIlNFTEVDVDo6dGFiaW5kZXgiLCJTT1VSQ0U6OnR5cGUiLCJU
-QUJMRTo6YWxpZ24iLCJUQUJMRTo6Ymdjb2xvciIsIlRBQkxFOjpib3JkZXIiLCJUQUJMRTo6Y2VsbHBh
-ZGRpbmciLCJUQUJMRTo6Y2VsbHNwYWNpbmciLCJUQUJMRTo6ZnJhbWUiLCJUQUJMRTo6cnVsZXMiLCJU
-QUJMRTo6c3VtbWFyeSIsIlRBQkxFOjp3aWR0aCIsIlRCT0RZOjphbGlnbiIsIlRCT0RZOjpjaGFyIiwi
-VEJPRFk6OmNoYXJvZmYiLCJUQk9EWTo6dmFsaWduIiwiVEQ6OmFiYnIiLCJURDo6YWxpZ24iLCJURDo6
-YXhpcyIsIlREOjpiZ2NvbG9yIiwiVEQ6OmNoYXIiLCJURDo6Y2hhcm9mZiIsIlREOjpjb2xzcGFuIiwi
-VEQ6OmhlYWRlcnMiLCJURDo6aGVpZ2h0IiwiVEQ6Om5vd3JhcCIsIlREOjpyb3dzcGFuIiwiVEQ6OnNj
-b3BlIiwiVEQ6OnZhbGlnbiIsIlREOjp3aWR0aCIsIlRFWFRBUkVBOjphY2Nlc3NrZXkiLCJURVhUQVJF
-QTo6YXV0b2NvbXBsZXRlIiwiVEVYVEFSRUE6OmNvbHMiLCJURVhUQVJFQTo6ZGlzYWJsZWQiLCJURVhU
-QVJFQTo6aW5wdXRtb2RlIiwiVEVYVEFSRUE6Om5hbWUiLCJURVhUQVJFQTo6cGxhY2Vob2xkZXIiLCJU
-RVhUQVJFQTo6cmVhZG9ubHkiLCJURVhUQVJFQTo6cmVxdWlyZWQiLCJURVhUQVJFQTo6cm93cyIsIlRF
-WFRBUkVBOjp0YWJpbmRleCIsIlRFWFRBUkVBOjp3cmFwIiwiVEZPT1Q6OmFsaWduIiwiVEZPT1Q6OmNo
-YXIiLCJURk9PVDo6Y2hhcm9mZiIsIlRGT09UOjp2YWxpZ24iLCJUSDo6YWJiciIsIlRIOjphbGlnbiIs
-IlRIOjpheGlzIiwiVEg6OmJnY29sb3IiLCJUSDo6Y2hhciIsIlRIOjpjaGFyb2ZmIiwiVEg6OmNvbHNw
-YW4iLCJUSDo6aGVhZGVycyIsIlRIOjpoZWlnaHQiLCJUSDo6bm93cmFwIiwiVEg6OnJvd3NwYW4iLCJU
-SDo6c2NvcGUiLCJUSDo6dmFsaWduIiwiVEg6OndpZHRoIiwiVEhFQUQ6OmFsaWduIiwiVEhFQUQ6OmNo
-YXIiLCJUSEVBRDo6Y2hhcm9mZiIsIlRIRUFEOjp2YWxpZ24iLCJUUjo6YWxpZ24iLCJUUjo6Ymdjb2xv
-ciIsIlRSOjpjaGFyIiwiVFI6OmNoYXJvZmYiLCJUUjo6dmFsaWduIiwiVFJBQ0s6OmRlZmF1bHQiLCJU
-UkFDSzo6a2luZCIsIlRSQUNLOjpsYWJlbCIsIlRSQUNLOjpzcmNsYW5nIiwiVUw6OmNvbXBhY3QiLCJV
-TDo6dHlwZSIsIlZJREVPOjpjb250cm9scyIsIlZJREVPOjpoZWlnaHQiLCJWSURFTzo6bG9vcCIsIlZJ
-REVPOjptZWRpYWdyb3VwIiwiVklERU86Om11dGVkIiwiVklERU86OnByZWxvYWQiLCJWSURFTzo6d2lk
-dGgiXSksdC5pKQpDLlZDPUguVk0ocyhbMCwwLDY1NDkwLDQ1MDU1LDY1NTM1LDM0ODE1LDY1NTM0LDE4
-NDMxXSksdC5WKQpDLm1LPUguVk0ocyhbMCwwLDI2NjI0LDEwMjMsNjU1MzQsMjA0Nyw2NTUzNCwyMDQ3
-XSksdC5WKQpDLlNxPUguVk0ocyhbIkhFQUQiLCJBUkVBIiwiQkFTRSIsIkJBU0VGT05UIiwiQlIiLCJD
-T0wiLCJDT0xHUk9VUCIsIkVNQkVEIiwiRlJBTUUiLCJGUkFNRVNFVCIsIkhSIiwiSU1BR0UiLCJJTUci
-LCJJTlBVVCIsIklTSU5ERVgiLCJMSU5LIiwiTUVUQSIsIlBBUkFNIiwiU09VUkNFIiwiU1RZTEUiLCJU
-SVRMRSIsIldCUiJdKSx0LmkpCkMuaFU9SC5WTShzKFtdKSx0LngpCkMuZG49SC5WTShzKFtdKSxILk4w
-KCJqZDxMTCo+IikpCkMueEQ9SC5WTShzKFtdKSx0LmkpCkMudG89SC5WTShzKFswLDAsMzI3MjIsMTIy
-ODcsNjU1MzQsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMucms9SC5WTShzKFtDLkFkLEMubmUsQy5t
-eSxDLnJ4LEMud1YsQy5mUl0pLEguTjAoImpkPEg3Kj4iKSkKQy5GMz1ILlZNKHMoWzAsMCwyNDU3Niwx
-MDIzLDY1NTM0LDM0ODE1LDY1NTM0LDE4NDMxXSksdC5WKQpDLmVhPUguVk0ocyhbMCwwLDMyNzU0LDEx
-MjYzLDY1NTM0LDM0ODE1LDY1NTM0LDE4NDMxXSksdC5WKQpDLlpKPUguVk0ocyhbMCwwLDMyNzIyLDEy
-Mjg3LDY1NTM1LDM0ODE1LDY1NTM0LDE4NDMxXSksdC5WKQpDLldkPUguVk0ocyhbMCwwLDY1NDkwLDEy
-Mjg3LDY1NTM1LDM0ODE1LDY1NTM0LDE4NDMxXSksdC5WKQpDLlF4PUguVk0ocyhbImJpbmQiLCJpZiIs
-InJlZiIsInJlcGVhdCIsInN5bnRheCJdKSx0LmkpCkMuQkk9SC5WTShzKFsiQTo6aHJlZiIsIkFSRUE6
-OmhyZWYiLCJCTE9DS1FVT1RFOjpjaXRlIiwiQk9EWTo6YmFja2dyb3VuZCIsIkNPTU1BTkQ6Omljb24i
-LCJERUw6OmNpdGUiLCJGT1JNOjphY3Rpb24iLCJJTUc6OnNyYyIsIklOUFVUOjpzcmMiLCJJTlM6OmNp
-dGUiLCJROjpjaXRlIiwiVklERU86OnBvc3RlciJdKSx0LmkpCkMuRHg9bmV3IEguTFAoMCx7fSxDLnhE
-LEguTjAoIkxQPHFVKix6TTxqOCo+Kj4iKSkKQy5DTT1uZXcgSC5MUCgwLHt9LEMueEQsSC5OMCgiTFA8
-cVUqLHFVKj4iKSkKQy5pSD1ILlZNKHMoW10pLEguTjAoImpkPEdEKj4iKSkKQy5XTz1uZXcgSC5MUCgw
-LHt9LEMuaUgsSC5OMCgiTFA8R0QqLEA+IikpCkMuWTI9bmV3IEwuTzkoIk5hdmlnYXRpb25UcmVlTm9k
-ZVR5cGUuZGlyZWN0b3J5IikKQy5yZj1uZXcgTC5POSgiTmF2aWdhdGlvblRyZWVOb2RlVHlwZS5maWxl
-IikKQy5UZT1uZXcgSC53digiY2FsbCIpCkMub0U9bmV3IFAuR1koITEpCkMud1E9bmV3IFAuRnkobnVs
-bCwyKX0pKCk7KGZ1bmN0aW9uIHN0YXRpY0ZpZWxkcygpeyQuem09bnVsbAokLnlqPTAKJC5tSj1udWxs
-CiQuUDQ9bnVsbAokLk5GPW51bGwKJC5UWD1udWxsCiQueDc9bnVsbAokLm53PW51bGwKJC52dj1udWxs
-CiQuQnY9bnVsbAokLlM2PW51bGwKJC5rOD1udWxsCiQubWc9bnVsbAokLlVEPSExCiQuWDM9Qy5OVQok
-LnhnPUguVk0oW10sSC5OMCgiamQ8TWg+IikpCiQueG89bnVsbAokLkJPPW51bGwKJC5sdD1udWxsCiQu
-RVU9bnVsbAokLm9yPVAuRmwodC5OLHQuWSkKJC5JUj1udWxsCiQuSTY9bnVsbAokLkZmPW51bGx9KSgp
-OyhmdW5jdGlvbiBsYXp5SW5pdGlhbGl6ZXJzKCl7dmFyIHM9aHVua0hlbHBlcnMubGF6eUZpbmFsLHI9
-aHVua0hlbHBlcnMubGF6eU9sZApzKCQsImZhIiwidyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5ZZygiXyRk
-YXJ0X2RhcnRDbG9zdXJlIil9KQpzKCQsIlUyIiwiU24iLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5T
-Nyh7CnRvU3RyaW5nOmZ1bmN0aW9uKCl7cmV0dXJuIiRyZWNlaXZlciQifX0pKX0pCnMoJCwieHEiLCJs
-cSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHskbWV0aG9kJDpudWxsLAp0b1N0cmluZzpmdW5j
-dGlvbigpe3JldHVybiIkcmVjZWl2ZXIkIn19KSl9KQpzKCQsIlIxIiwiTjkiLGZ1bmN0aW9uKCl7cmV0
-dXJuIEguY00oSC5TNyhudWxsKSl9KQpzKCQsImZOIiwiaUkiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00o
-ZnVuY3Rpb24oKXt2YXIgJGFyZ3VtZW50c0V4cHIkPSckYXJndW1lbnRzJCcKdHJ5e251bGwuJG1ldGhv
-ZCQoJGFyZ3VtZW50c0V4cHIkKX1jYXRjaChxKXtyZXR1cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsInFp
-IiwiVU4iLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5TNyh2b2lkIDApKX0pCnMoJCwicloiLCJaaCIs
-ZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3ZhciAkYXJndW1lbnRzRXhwciQ9JyRhcmd1
-bWVudHMkJwp0cnl7KHZvaWQgMCkuJG1ldGhvZCQoJGFyZ3VtZW50c0V4cHIkKX1jYXRjaChxKXtyZXR1
-cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsImtxIiwick4iLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5N
-aihudWxsKSl9KQpzKCQsInR0IiwiYzMiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oZnVuY3Rpb24oKXt0
-cnl7bnVsbC4kbWV0aG9kJH1jYXRjaChxKXtyZXR1cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsImR0Iiwi
-SEsiLGZ1bmN0aW9uKCl7cmV0dXJuIEguY00oSC5Naih2b2lkIDApKX0pCnMoJCwiQTciLCJyMSIsZnVu
-Y3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3RyeXsodm9pZCAwKS4kbWV0aG9kJH1jYXRjaChx
-KXtyZXR1cm4gcS5tZXNzYWdlfX0oKSl9KQpzKCQsIldjIiwidXQiLGZ1bmN0aW9uKCl7cmV0dXJuIFAu
-T2ooKX0pCnMoJCwia2giLCJyZiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFAucGcoKS4kMCgpfSkKcygk
-LCJkSCIsIkhHIixmdW5jdGlvbigpe3JldHVybiBuZXcgUC5jMigpLiQwKCl9KQpzKCQsImJ0IiwiVjci
-LGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBJbnQ4QXJyYXkoSC5YRihILlZNKFstMiwtMiwtMiwtMiwtMiwt
-MiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwt
-MiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMiwtMSwtMiwtMiwtMiwtMiwtMiw2MiwtMiw2
-MiwtMiw2Myw1Miw1Myw1NCw1NSw1Niw1Nyw1OCw1OSw2MCw2MSwtMiwtMiwtMiwtMSwtMiwtMiwtMiww
-LDEsMiwzLDQsNSw2LDcsOCw5LDEwLDExLDEyLDEzLDE0LDE1LDE2LDE3LDE4LDE5LDIwLDIxLDIyLDIz
-LDI0LDI1LC0yLC0yLC0yLC0yLDYzLC0yLDI2LDI3LDI4LDI5LDMwLDMxLDMyLDMzLDM0LDM1LDM2LDM3
-LDM4LDM5LDQwLDQxLDQyLDQzLDQ0LDQ1LDQ2LDQ3LDQ4LDQ5LDUwLDUxLC0yLC0yLC0yLC0yLC0yXSx0
-LmEpKSl9KQpzKCQsIk01Iiwid1EiLGZ1bmN0aW9uKCl7cmV0dXJuIHR5cGVvZiBwcm9jZXNzIT0idW5k
-ZWZpbmVkIiYmT2JqZWN0LnByb3RvdHlwZS50b1N0cmluZy5jYWxsKHByb2Nlc3MpPT0iW29iamVjdCBw
-cm9jZXNzXSImJnByb2Nlc3MucGxhdGZvcm09PSJ3aW4zMiJ9KQpzKCQsIm1mIiwiejQiLGZ1bmN0aW9u
-KCl7cmV0dXJuIFAubnUoIl5bXFwtXFwuMC05QS1aX2Eten5dKiQiKX0pCnMoJCwiT1EiLCJ2WiIsZnVu
-Y3Rpb24oKXtyZXR1cm4gUC5LTigpfSkKcygkLCJTQyIsIkFOIixmdW5jdGlvbigpe3JldHVybiBQLnRN
-KFsiQSIsIkFCQlIiLCJBQ1JPTllNIiwiQUREUkVTUyIsIkFSRUEiLCJBUlRJQ0xFIiwiQVNJREUiLCJB
-VURJTyIsIkIiLCJCREkiLCJCRE8iLCJCSUciLCJCTE9DS1FVT1RFIiwiQlIiLCJCVVRUT04iLCJDQU5W
-QVMiLCJDQVBUSU9OIiwiQ0VOVEVSIiwiQ0lURSIsIkNPREUiLCJDT0wiLCJDT0xHUk9VUCIsIkNPTU1B
-TkQiLCJEQVRBIiwiREFUQUxJU1QiLCJERCIsIkRFTCIsIkRFVEFJTFMiLCJERk4iLCJESVIiLCJESVYi
-LCJETCIsIkRUIiwiRU0iLCJGSUVMRFNFVCIsIkZJR0NBUFRJT04iLCJGSUdVUkUiLCJGT05UIiwiRk9P
-VEVSIiwiRk9STSIsIkgxIiwiSDIiLCJIMyIsIkg0IiwiSDUiLCJINiIsIkhFQURFUiIsIkhHUk9VUCIs
-IkhSIiwiSSIsIklGUkFNRSIsIklNRyIsIklOUFVUIiwiSU5TIiwiS0JEIiwiTEFCRUwiLCJMRUdFTkQi
-LCJMSSIsIk1BUCIsIk1BUksiLCJNRU5VIiwiTUVURVIiLCJOQVYiLCJOT0JSIiwiT0wiLCJPUFRHUk9V
-UCIsIk9QVElPTiIsIk9VVFBVVCIsIlAiLCJQUkUiLCJQUk9HUkVTUyIsIlEiLCJTIiwiU0FNUCIsIlNF
-Q1RJT04iLCJTRUxFQ1QiLCJTTUFMTCIsIlNPVVJDRSIsIlNQQU4iLCJTVFJJS0UiLCJTVFJPTkciLCJT
-VUIiLCJTVU1NQVJZIiwiU1VQIiwiVEFCTEUiLCJUQk9EWSIsIlREIiwiVEVYVEFSRUEiLCJURk9PVCIs
-IlRIIiwiVEhFQUQiLCJUSU1FIiwiVFIiLCJUUkFDSyIsIlRUIiwiVSIsIlVMIiwiVkFSIiwiVklERU8i
-LCJXQlIiXSx0Lk4pfSkKcygkLCJYNCIsImhHIixmdW5jdGlvbigpe3JldHVybiBQLm51KCJeXFxTKyQi
-KX0pCnMoJCwid08iLCJvdyIsZnVuY3Rpb24oKXtyZXR1cm4gUC5ORChzZWxmKX0pCnMoJCwia3QiLCJS
-OCIsZnVuY3Rpb24oKXtyZXR1cm4gSC5ZZygiXyRkYXJ0X2RhcnRPYmplY3QiKX0pCnMoJCwiZksiLCJr
-SSIsZnVuY3Rpb24oKXtyZXR1cm4gZnVuY3Rpb24gRGFydE9iamVjdChhKXt0aGlzLm89YX19KQpyKCQs
-InF0IiwiekIiLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBULm1RKCl9KQpyKCQsIk9sIiwiVUUiLGZ1bmN0
-aW9uKCl7cmV0dXJuIFAuaEsoQy5vbC5nbVcoVy54MygpKS5ocmVmKS5naFkoKS5xKDAsImF1dGhUb2tl
-biIpfSkKcigkLCJoVCIsInlQIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3Rvcigi
-LmVkaXQtbGlzdCAucGFuZWwtY29udGVudCIpfSkKcigkLCJXNiIsImhMIixmdW5jdGlvbigpe3JldHVy
-biBXLlpyKCkucXVlcnlTZWxlY3RvcigiLmVkaXQtcGFuZWwgLnBhbmVsLWNvbnRlbnQiKX0pCnIoJCwi
-VFIiLCJEVyIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoImZvb3RlciIpfSkK
-cigkLCJFWSIsImZpIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiaGVhZGVy
-Iil9KQpyKCQsImF2IiwiRDkiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIj
-dW5pdC1uYW1lIil9KQpyKCQsInQwIiwiYk4iLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNl
-bGVjdG9yKCIjbWlncmF0ZS11bml0LXN0YXR1cy1pY29uLWxhYmVsIil9KQpyKCQsImJBIiwiYzAiLGZ1
-bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIjbWlncmF0ZS11bml0LXN0YXR1cy1p
-Y29uIil9KQpyKCQsImZlIiwiS0ciLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBMLlhBKCl9KQpzKCQsImVv
-IiwiblUiLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBNLmxJKCQuSGsoKSl9KQpzKCQsInlyIiwiYkQiLGZ1
-bmN0aW9uKCl7cmV0dXJuIG5ldyBFLk9GKFAubnUoIi8iKSxQLm51KCJbXi9dJCIpLFAubnUoIl4vIikp
-fSkKcygkLCJNayIsIktrIixmdW5jdGlvbigpe3JldHVybiBuZXcgTC5JVihQLm51KCJbL1xcXFxdIiks
-UC5udSgiW14vXFxcXF0kIiksUC5udSgiXihcXFxcXFxcXFteXFxcXF0rXFxcXFteXFxcXC9dK3xbYS16
-QS1aXTpbL1xcXFxdKSIpLFAubnUoIl5bL1xcXFxdKD8hWy9cXFxcXSkiKSl9KQpzKCQsImFrIiwiRWIi
-LGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBGLnJ1KFAubnUoIi8iKSxQLm51KCIoXlthLXpBLVpdWy0rLmEt
-ekEtWlxcZF0qOi8vfFteL10pJCIpLFAubnUoIlthLXpBLVpdWy0rLmEtekEtWlxcZF0qOi8vW14vXSoi
-KSxQLm51KCJeLyIpKX0pCnMoJCwibHMiLCJIayIsZnVuY3Rpb24oKXtyZXR1cm4gTy5SaCgpfSl9KSgp
-OyhmdW5jdGlvbiBuYXRpdmVTdXBwb3J0KCl7IWZ1bmN0aW9uKCl7dmFyIHM9ZnVuY3Rpb24oYSl7dmFy
-IG09e30KbVthXT0xCnJldHVybiBPYmplY3Qua2V5cyhodW5rSGVscGVycy5jb252ZXJ0VG9GYXN0T2Jq
-ZWN0KG0pKVswXX0Kdi5nZXRJc29sYXRlVGFnPWZ1bmN0aW9uKGEpe3JldHVybiBzKCJfX19kYXJ0XyIr
-YSt2Lmlzb2xhdGVUYWcpfQp2YXIgcj0iX19fZGFydF9pc29sYXRlX3RhZ3NfIgp2YXIgcT1PYmplY3Rb
-cl18fChPYmplY3Rbcl09T2JqZWN0LmNyZWF0ZShudWxsKSkKdmFyIHA9Il9aeFl4WCIKZm9yKHZhciBv
-PTA7O28rKyl7dmFyIG49cyhwKyJfIitvKyJfIikKaWYoIShuIGluIHEpKXtxW25dPTEKdi5pc29sYXRl
-VGFnPW4KYnJlYWt9fXYuZGlzcGF0Y2hQcm9wZXJ0eU5hbWU9di5nZXRJc29sYXRlVGFnKCJkaXNwYXRj
-aF9yZWNvcmQiKX0oKQpodW5rSGVscGVycy5zZXRPclVwZGF0ZUludGVyY2VwdG9yc0J5VGFnKHtET01F
-cnJvcjpKLkd2LE1lZGlhRXJyb3I6Si5HdixOYXZpZ2F0b3I6Si5HdixOYXZpZ2F0b3JDb25jdXJyZW50
-SGFyZHdhcmU6Si5HdixOYXZpZ2F0b3JVc2VyTWVkaWFFcnJvcjpKLkd2LE92ZXJjb25zdHJhaW5lZEVy
-cm9yOkouR3YsUG9zaXRpb25FcnJvcjpKLkd2LFJhbmdlOkouR3YsU1FMRXJyb3I6Si5HdixEYXRhVmll
-dzpILkVULEFycmF5QnVmZmVyVmlldzpILkVULEZsb2F0MzJBcnJheTpILkRnLEZsb2F0NjRBcnJheTpI
-LkRnLEludDE2QXJyYXk6SC54aixJbnQzMkFycmF5OkguZEUsSW50OEFycmF5OkguWkEsVWludDE2QXJy
-YXk6SC5kVCxVaW50MzJBcnJheTpILlBxLFVpbnQ4Q2xhbXBlZEFycmF5OkguZUUsQ2FudmFzUGl4ZWxB
-cnJheTpILmVFLFVpbnQ4QXJyYXk6SC5WNixIVE1MQXVkaW9FbGVtZW50OlcucUUsSFRNTEJSRWxlbWVu
-dDpXLnFFLEhUTUxCdXR0b25FbGVtZW50OlcucUUsSFRNTENhbnZhc0VsZW1lbnQ6Vy5xRSxIVE1MQ29u
-dGVudEVsZW1lbnQ6Vy5xRSxIVE1MRExpc3RFbGVtZW50OlcucUUsSFRNTERhdGFFbGVtZW50OlcucUUs
-SFRNTERhdGFMaXN0RWxlbWVudDpXLnFFLEhUTUxEZXRhaWxzRWxlbWVudDpXLnFFLEhUTUxEaWFsb2dF
-bGVtZW50OlcucUUsSFRNTERpdkVsZW1lbnQ6Vy5xRSxIVE1MRW1iZWRFbGVtZW50OlcucUUsSFRNTEZp
-ZWxkU2V0RWxlbWVudDpXLnFFLEhUTUxIUkVsZW1lbnQ6Vy5xRSxIVE1MSGVhZEVsZW1lbnQ6Vy5xRSxI
-VE1MSGVhZGluZ0VsZW1lbnQ6Vy5xRSxIVE1MSHRtbEVsZW1lbnQ6Vy5xRSxIVE1MSUZyYW1lRWxlbWVu
-dDpXLnFFLEhUTUxJbWFnZUVsZW1lbnQ6Vy5xRSxIVE1MSW5wdXRFbGVtZW50OlcucUUsSFRNTExJRWxl
-bWVudDpXLnFFLEhUTUxMYWJlbEVsZW1lbnQ6Vy5xRSxIVE1MTGVnZW5kRWxlbWVudDpXLnFFLEhUTUxM
-aW5rRWxlbWVudDpXLnFFLEhUTUxNYXBFbGVtZW50OlcucUUsSFRNTE1lZGlhRWxlbWVudDpXLnFFLEhU
-TUxNZW51RWxlbWVudDpXLnFFLEhUTUxNZXRhRWxlbWVudDpXLnFFLEhUTUxNZXRlckVsZW1lbnQ6Vy5x
-RSxIVE1MTW9kRWxlbWVudDpXLnFFLEhUTUxPTGlzdEVsZW1lbnQ6Vy5xRSxIVE1MT2JqZWN0RWxlbWVu
-dDpXLnFFLEhUTUxPcHRHcm91cEVsZW1lbnQ6Vy5xRSxIVE1MT3B0aW9uRWxlbWVudDpXLnFFLEhUTUxP
-dXRwdXRFbGVtZW50OlcucUUsSFRNTFBhcmFtRWxlbWVudDpXLnFFLEhUTUxQaWN0dXJlRWxlbWVudDpX
-LnFFLEhUTUxQcmVFbGVtZW50OlcucUUsSFRNTFByb2dyZXNzRWxlbWVudDpXLnFFLEhUTUxRdW90ZUVs
-ZW1lbnQ6Vy5xRSxIVE1MU2NyaXB0RWxlbWVudDpXLnFFLEhUTUxTaGFkb3dFbGVtZW50OlcucUUsSFRN
-TFNsb3RFbGVtZW50OlcucUUsSFRNTFNvdXJjZUVsZW1lbnQ6Vy5xRSxIVE1MU3BhbkVsZW1lbnQ6Vy5x
-RSxIVE1MU3R5bGVFbGVtZW50OlcucUUsSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQ6Vy5xRSxIVE1MVGFi
-bGVDZWxsRWxlbWVudDpXLnFFLEhUTUxUYWJsZURhdGFDZWxsRWxlbWVudDpXLnFFLEhUTUxUYWJsZUhl
-YWRlckNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlQ29sRWxlbWVudDpXLnFFLEhUTUxUZXh0QXJlYUVs
-ZW1lbnQ6Vy5xRSxIVE1MVGltZUVsZW1lbnQ6Vy5xRSxIVE1MVGl0bGVFbGVtZW50OlcucUUsSFRNTFRy
-YWNrRWxlbWVudDpXLnFFLEhUTUxVTGlzdEVsZW1lbnQ6Vy5xRSxIVE1MVW5rbm93bkVsZW1lbnQ6Vy5x
-RSxIVE1MVmlkZW9FbGVtZW50OlcucUUsSFRNTERpcmVjdG9yeUVsZW1lbnQ6Vy5xRSxIVE1MRm9udEVs
-ZW1lbnQ6Vy5xRSxIVE1MRnJhbWVFbGVtZW50OlcucUUsSFRNTEZyYW1lU2V0RWxlbWVudDpXLnFFLEhU
-TUxNYXJxdWVlRWxlbWVudDpXLnFFLEhUTUxFbGVtZW50OlcucUUsSFRNTEFuY2hvckVsZW1lbnQ6Vy5H
-aCxIVE1MQXJlYUVsZW1lbnQ6Vy5mWSxIVE1MQmFzZUVsZW1lbnQ6Vy5uQixCbG9iOlcuQXosSFRNTEJv
-ZHlFbGVtZW50OlcuUVAsQ0RBVEFTZWN0aW9uOlcubngsQ2hhcmFjdGVyRGF0YTpXLm54LENvbW1lbnQ6
-Vy5ueCxQcm9jZXNzaW5nSW5zdHJ1Y3Rpb246Vy5ueCxUZXh0OlcubngsQ1NTU3R5bGVEZWNsYXJhdGlv
-bjpXLm9KLE1TU3R5bGVDU1NQcm9wZXJ0aWVzOlcub0osQ1NTMlByb3BlcnRpZXM6Vy5vSixYTUxEb2N1
-bWVudDpXLlFGLERvY3VtZW50OlcuUUYsRE9NRXhjZXB0aW9uOlcuTmgsRE9NSW1wbGVtZW50YXRpb246
-Vy5hZSxET01SZWN0UmVhZE9ubHk6Vy5JQixET01Ub2tlbkxpc3Q6Vy5uNyxFbGVtZW50OlcuY3YsQWJv
-cnRQYXltZW50RXZlbnQ6Vy5lYSxBbmltYXRpb25FdmVudDpXLmVhLEFuaW1hdGlvblBsYXliYWNrRXZl
-bnQ6Vy5lYSxBcHBsaWNhdGlvbkNhY2hlRXJyb3JFdmVudDpXLmVhLEJhY2tncm91bmRGZXRjaENsaWNr
-RXZlbnQ6Vy5lYSxCYWNrZ3JvdW5kRmV0Y2hFdmVudDpXLmVhLEJhY2tncm91bmRGZXRjaEZhaWxFdmVu
-dDpXLmVhLEJhY2tncm91bmRGZXRjaGVkRXZlbnQ6Vy5lYSxCZWZvcmVJbnN0YWxsUHJvbXB0RXZlbnQ6
-Vy5lYSxCZWZvcmVVbmxvYWRFdmVudDpXLmVhLEJsb2JFdmVudDpXLmVhLENhbk1ha2VQYXltZW50RXZl
-bnQ6Vy5lYSxDbGlwYm9hcmRFdmVudDpXLmVhLENsb3NlRXZlbnQ6Vy5lYSxDdXN0b21FdmVudDpXLmVh
-LERldmljZU1vdGlvbkV2ZW50OlcuZWEsRGV2aWNlT3JpZW50YXRpb25FdmVudDpXLmVhLEVycm9yRXZl
-bnQ6Vy5lYSxFeHRlbmRhYmxlRXZlbnQ6Vy5lYSxFeHRlbmRhYmxlTWVzc2FnZUV2ZW50OlcuZWEsRmV0
-Y2hFdmVudDpXLmVhLEZvbnRGYWNlU2V0TG9hZEV2ZW50OlcuZWEsRm9yZWlnbkZldGNoRXZlbnQ6Vy5l
-YSxHYW1lcGFkRXZlbnQ6Vy5lYSxIYXNoQ2hhbmdlRXZlbnQ6Vy5lYSxJbnN0YWxsRXZlbnQ6Vy5lYSxN
-ZWRpYUVuY3J5cHRlZEV2ZW50OlcuZWEsTWVkaWFLZXlNZXNzYWdlRXZlbnQ6Vy5lYSxNZWRpYVF1ZXJ5
-TGlzdEV2ZW50OlcuZWEsTWVkaWFTdHJlYW1FdmVudDpXLmVhLE1lZGlhU3RyZWFtVHJhY2tFdmVudDpX
-LmVhLE1lc3NhZ2VFdmVudDpXLmVhLE1JRElDb25uZWN0aW9uRXZlbnQ6Vy5lYSxNSURJTWVzc2FnZUV2
-ZW50OlcuZWEsTXV0YXRpb25FdmVudDpXLmVhLE5vdGlmaWNhdGlvbkV2ZW50OlcuZWEsUGFnZVRyYW5z
-aXRpb25FdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0RXZlbnQ6Vy5lYSxQYXltZW50UmVxdWVzdFVwZGF0
-ZUV2ZW50OlcuZWEsUG9wU3RhdGVFdmVudDpXLmVhLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25BdmFpbGFi
-bGVFdmVudDpXLmVhLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25DbG9zZUV2ZW50OlcuZWEsUHJvbWlzZVJl
-amVjdGlvbkV2ZW50OlcuZWEsUHVzaEV2ZW50OlcuZWEsUlRDRGF0YUNoYW5uZWxFdmVudDpXLmVhLFJU
-Q0RUTUZUb25lQ2hhbmdlRXZlbnQ6Vy5lYSxSVENQZWVyQ29ubmVjdGlvbkljZUV2ZW50OlcuZWEsUlRD
-VHJhY2tFdmVudDpXLmVhLFNlY3VyaXR5UG9saWN5VmlvbGF0aW9uRXZlbnQ6Vy5lYSxTZW5zb3JFcnJv
-ckV2ZW50OlcuZWEsU3BlZWNoUmVjb2duaXRpb25FcnJvcjpXLmVhLFNwZWVjaFJlY29nbml0aW9uRXZl
-bnQ6Vy5lYSxTcGVlY2hTeW50aGVzaXNFdmVudDpXLmVhLFN0b3JhZ2VFdmVudDpXLmVhLFN5bmNFdmVu
-dDpXLmVhLFRyYWNrRXZlbnQ6Vy5lYSxUcmFuc2l0aW9uRXZlbnQ6Vy5lYSxXZWJLaXRUcmFuc2l0aW9u
-RXZlbnQ6Vy5lYSxWUkRldmljZUV2ZW50OlcuZWEsVlJEaXNwbGF5RXZlbnQ6Vy5lYSxWUlNlc3Npb25F
-dmVudDpXLmVhLE1vam9JbnRlcmZhY2VSZXF1ZXN0RXZlbnQ6Vy5lYSxVU0JDb25uZWN0aW9uRXZlbnQ6
-Vy5lYSxJREJWZXJzaW9uQ2hhbmdlRXZlbnQ6Vy5lYSxBdWRpb1Byb2Nlc3NpbmdFdmVudDpXLmVhLE9m
-ZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudDpXLmVhLFdlYkdMQ29udGV4dEV2ZW50OlcuZWEsRXZlbnQ6
-Vy5lYSxJbnB1dEV2ZW50OlcuZWEsU3VibWl0RXZlbnQ6Vy5lYSxFdmVudFRhcmdldDpXLkQwLEZpbGU6
-Vy5oSCxIVE1MRm9ybUVsZW1lbnQ6Vy5oNCxIaXN0b3J5OlcuYnIsSFRNTERvY3VtZW50OlcuVmIsWE1M
-SHR0cFJlcXVlc3Q6Vy5mSixYTUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0Olcud2EsSW1hZ2VEYXRhOlcu
-U2csTG9jYXRpb246Vy53NyxNb3VzZUV2ZW50OlcuQWosRHJhZ0V2ZW50OlcuQWosUG9pbnRlckV2ZW50
-OlcuQWosV2hlZWxFdmVudDpXLkFqLERvY3VtZW50RnJhZ21lbnQ6Vy51SCxTaGFkb3dSb290OlcudUgs
-RG9jdW1lbnRUeXBlOlcudUgsTm9kZTpXLnVILE5vZGVMaXN0OlcuQkgsUmFkaW9Ob2RlTGlzdDpXLkJI
-LEhUTUxQYXJhZ3JhcGhFbGVtZW50OlcuU04sUHJvZ3Jlc3NFdmVudDpXLmV3LFJlc291cmNlUHJvZ3Jl
-c3NFdmVudDpXLmV3LEhUTUxTZWxlY3RFbGVtZW50OlcubHAsSFRNTFRhYmxlRWxlbWVudDpXLlRiLEhU
-TUxUYWJsZVJvd0VsZW1lbnQ6Vy5JdixIVE1MVGFibGVTZWN0aW9uRWxlbWVudDpXLldQLEhUTUxUZW1w
-bGF0ZUVsZW1lbnQ6Vy55WSxDb21wb3NpdGlvbkV2ZW50OlcudzYsRm9jdXNFdmVudDpXLnc2LEtleWJv
-YXJkRXZlbnQ6Vy53NixUZXh0RXZlbnQ6Vy53NixUb3VjaEV2ZW50OlcudzYsVUlFdmVudDpXLnc2LFdp
-bmRvdzpXLks1LERPTVdpbmRvdzpXLks1LERlZGljYXRlZFdvcmtlckdsb2JhbFNjb3BlOlcuQ20sU2Vy
-dmljZVdvcmtlckdsb2JhbFNjb3BlOlcuQ20sU2hhcmVkV29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxXb3Jr
-ZXJHbG9iYWxTY29wZTpXLkNtLEF0dHI6Vy5DUSxDbGllbnRSZWN0OlcudzQsRE9NUmVjdDpXLnc0LE5h
-bWVkTm9kZU1hcDpXLnJoLE1vek5hbWVkQXR0ck1hcDpXLnJoLElEQktleVJhbmdlOlAuaEYsU1ZHU2Ny
-aXB0RWxlbWVudDpQLm5kLFNWR0FFbGVtZW50OlAuaGksU1ZHQW5pbWF0ZUVsZW1lbnQ6UC5oaSxTVkdB
-bmltYXRlTW90aW9uRWxlbWVudDpQLmhpLFNWR0FuaW1hdGVUcmFuc2Zvcm1FbGVtZW50OlAuaGksU1ZH
-QW5pbWF0aW9uRWxlbWVudDpQLmhpLFNWR0NpcmNsZUVsZW1lbnQ6UC5oaSxTVkdDbGlwUGF0aEVsZW1l
-bnQ6UC5oaSxTVkdEZWZzRWxlbWVudDpQLmhpLFNWR0Rlc2NFbGVtZW50OlAuaGksU1ZHRGlzY2FyZEVs
-ZW1lbnQ6UC5oaSxTVkdFbGxpcHNlRWxlbWVudDpQLmhpLFNWR0ZFQmxlbmRFbGVtZW50OlAuaGksU1ZH
-RkVDb2xvck1hdHJpeEVsZW1lbnQ6UC5oaSxTVkdGRUNvbXBvbmVudFRyYW5zZmVyRWxlbWVudDpQLmhp
-LFNWR0ZFQ29tcG9zaXRlRWxlbWVudDpQLmhpLFNWR0ZFQ29udm9sdmVNYXRyaXhFbGVtZW50OlAuaGks
-U1ZHRkVEaWZmdXNlTGlnaHRpbmdFbGVtZW50OlAuaGksU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVtZW50
-OlAuaGksU1ZHRkVEaXN0YW50TGlnaHRFbGVtZW50OlAuaGksU1ZHRkVGbG9vZEVsZW1lbnQ6UC5oaSxT
-VkdGRUZ1bmNBRWxlbWVudDpQLmhpLFNWR0ZFRnVuY0JFbGVtZW50OlAuaGksU1ZHRkVGdW5jR0VsZW1l
-bnQ6UC5oaSxTVkdGRUZ1bmNSRWxlbWVudDpQLmhpLFNWR0ZFR2F1c3NpYW5CbHVyRWxlbWVudDpQLmhp
-LFNWR0ZFSW1hZ2VFbGVtZW50OlAuaGksU1ZHRkVNZXJnZUVsZW1lbnQ6UC5oaSxTVkdGRU1lcmdlTm9k
-ZUVsZW1lbnQ6UC5oaSxTVkdGRU1vcnBob2xvZ3lFbGVtZW50OlAuaGksU1ZHRkVPZmZzZXRFbGVtZW50
-OlAuaGksU1ZHRkVQb2ludExpZ2h0RWxlbWVudDpQLmhpLFNWR0ZFU3BlY3VsYXJMaWdodGluZ0VsZW1l
-bnQ6UC5oaSxTVkdGRVNwb3RMaWdodEVsZW1lbnQ6UC5oaSxTVkdGRVRpbGVFbGVtZW50OlAuaGksU1ZH
-RkVUdXJidWxlbmNlRWxlbWVudDpQLmhpLFNWR0ZpbHRlckVsZW1lbnQ6UC5oaSxTVkdGb3JlaWduT2Jq
-ZWN0RWxlbWVudDpQLmhpLFNWR0dFbGVtZW50OlAuaGksU1ZHR2VvbWV0cnlFbGVtZW50OlAuaGksU1ZH
-R3JhcGhpY3NFbGVtZW50OlAuaGksU1ZHSW1hZ2VFbGVtZW50OlAuaGksU1ZHTGluZUVsZW1lbnQ6UC5o
-aSxTVkdMaW5lYXJHcmFkaWVudEVsZW1lbnQ6UC5oaSxTVkdNYXJrZXJFbGVtZW50OlAuaGksU1ZHTWFz
-a0VsZW1lbnQ6UC5oaSxTVkdNZXRhZGF0YUVsZW1lbnQ6UC5oaSxTVkdQYXRoRWxlbWVudDpQLmhpLFNW
-R1BhdHRlcm5FbGVtZW50OlAuaGksU1ZHUG9seWdvbkVsZW1lbnQ6UC5oaSxTVkdQb2x5bGluZUVsZW1l
-bnQ6UC5oaSxTVkdSYWRpYWxHcmFkaWVudEVsZW1lbnQ6UC5oaSxTVkdSZWN0RWxlbWVudDpQLmhpLFNW
-R1NldEVsZW1lbnQ6UC5oaSxTVkdTdG9wRWxlbWVudDpQLmhpLFNWR1N0eWxlRWxlbWVudDpQLmhpLFNW
-R1NWR0VsZW1lbnQ6UC5oaSxTVkdTd2l0Y2hFbGVtZW50OlAuaGksU1ZHU3ltYm9sRWxlbWVudDpQLmhp
-LFNWR1RTcGFuRWxlbWVudDpQLmhpLFNWR1RleHRDb250ZW50RWxlbWVudDpQLmhpLFNWR1RleHRFbGVt
-ZW50OlAuaGksU1ZHVGV4dFBhdGhFbGVtZW50OlAuaGksU1ZHVGV4dFBvc2l0aW9uaW5nRWxlbWVudDpQ
-LmhpLFNWR1RpdGxlRWxlbWVudDpQLmhpLFNWR1VzZUVsZW1lbnQ6UC5oaSxTVkdWaWV3RWxlbWVudDpQ
-LmhpLFNWR0dyYWRpZW50RWxlbWVudDpQLmhpLFNWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25FbGVt
-ZW50OlAuaGksU1ZHRkVEcm9wU2hhZG93RWxlbWVudDpQLmhpLFNWR01QYXRoRWxlbWVudDpQLmhpLFNW
-R0VsZW1lbnQ6UC5oaX0pCmh1bmtIZWxwZXJzLnNldE9yVXBkYXRlTGVhZlRhZ3Moe0RPTUVycm9yOnRy
-dWUsTWVkaWFFcnJvcjp0cnVlLE5hdmlnYXRvcjp0cnVlLE5hdmlnYXRvckNvbmN1cnJlbnRIYXJkd2Fy
-ZTp0cnVlLE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOnRydWUsT3ZlcmNvbnN0cmFpbmVkRXJyb3I6dHJ1
-ZSxQb3NpdGlvbkVycm9yOnRydWUsUmFuZ2U6dHJ1ZSxTUUxFcnJvcjp0cnVlLERhdGFWaWV3OnRydWUs
-QXJyYXlCdWZmZXJWaWV3OmZhbHNlLEZsb2F0MzJBcnJheTp0cnVlLEZsb2F0NjRBcnJheTp0cnVlLElu
-dDE2QXJyYXk6dHJ1ZSxJbnQzMkFycmF5OnRydWUsSW50OEFycmF5OnRydWUsVWludDE2QXJyYXk6dHJ1
-ZSxVaW50MzJBcnJheTp0cnVlLFVpbnQ4Q2xhbXBlZEFycmF5OnRydWUsQ2FudmFzUGl4ZWxBcnJheTp0
-cnVlLFVpbnQ4QXJyYXk6ZmFsc2UsSFRNTEF1ZGlvRWxlbWVudDp0cnVlLEhUTUxCUkVsZW1lbnQ6dHJ1
-ZSxIVE1MQnV0dG9uRWxlbWVudDp0cnVlLEhUTUxDYW52YXNFbGVtZW50OnRydWUsSFRNTENvbnRlbnRF
-bGVtZW50OnRydWUsSFRNTERMaXN0RWxlbWVudDp0cnVlLEhUTUxEYXRhRWxlbWVudDp0cnVlLEhUTUxE
-YXRhTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MRGV0YWlsc0VsZW1lbnQ6dHJ1ZSxIVE1MRGlhbG9nRWxlbWVu
-dDp0cnVlLEhUTUxEaXZFbGVtZW50OnRydWUsSFRNTEVtYmVkRWxlbWVudDp0cnVlLEhUTUxGaWVsZFNl
-dEVsZW1lbnQ6dHJ1ZSxIVE1MSFJFbGVtZW50OnRydWUsSFRNTEhlYWRFbGVtZW50OnRydWUsSFRNTEhl
-YWRpbmdFbGVtZW50OnRydWUsSFRNTEh0bWxFbGVtZW50OnRydWUsSFRNTElGcmFtZUVsZW1lbnQ6dHJ1
-ZSxIVE1MSW1hZ2VFbGVtZW50OnRydWUsSFRNTElucHV0RWxlbWVudDp0cnVlLEhUTUxMSUVsZW1lbnQ6
-dHJ1ZSxIVE1MTGFiZWxFbGVtZW50OnRydWUsSFRNTExlZ2VuZEVsZW1lbnQ6dHJ1ZSxIVE1MTGlua0Vs
-ZW1lbnQ6dHJ1ZSxIVE1MTWFwRWxlbWVudDp0cnVlLEhUTUxNZWRpYUVsZW1lbnQ6dHJ1ZSxIVE1MTWVu
-dUVsZW1lbnQ6dHJ1ZSxIVE1MTWV0YUVsZW1lbnQ6dHJ1ZSxIVE1MTWV0ZXJFbGVtZW50OnRydWUsSFRN
-TE1vZEVsZW1lbnQ6dHJ1ZSxIVE1MT0xpc3RFbGVtZW50OnRydWUsSFRNTE9iamVjdEVsZW1lbnQ6dHJ1
-ZSxIVE1MT3B0R3JvdXBFbGVtZW50OnRydWUsSFRNTE9wdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MT3V0cHV0
-RWxlbWVudDp0cnVlLEhUTUxQYXJhbUVsZW1lbnQ6dHJ1ZSxIVE1MUGljdHVyZUVsZW1lbnQ6dHJ1ZSxI
-VE1MUHJlRWxlbWVudDp0cnVlLEhUTUxQcm9ncmVzc0VsZW1lbnQ6dHJ1ZSxIVE1MUXVvdGVFbGVtZW50
-OnRydWUsSFRNTFNjcmlwdEVsZW1lbnQ6dHJ1ZSxIVE1MU2hhZG93RWxlbWVudDp0cnVlLEhUTUxTbG90
-RWxlbWVudDp0cnVlLEhUTUxTb3VyY2VFbGVtZW50OnRydWUsSFRNTFNwYW5FbGVtZW50OnRydWUsSFRN
-TFN0eWxlRWxlbWVudDp0cnVlLEhUTUxUYWJsZUNhcHRpb25FbGVtZW50OnRydWUsSFRNTFRhYmxlQ2Vs
-bEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVEYXRhQ2VsbEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVIZWFkZXJD
-ZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZUNvbEVsZW1lbnQ6dHJ1ZSxIVE1MVGV4dEFyZWFFbGVtZW50
-OnRydWUsSFRNTFRpbWVFbGVtZW50OnRydWUsSFRNTFRpdGxlRWxlbWVudDp0cnVlLEhUTUxUcmFja0Vs
-ZW1lbnQ6dHJ1ZSxIVE1MVUxpc3RFbGVtZW50OnRydWUsSFRNTFVua25vd25FbGVtZW50OnRydWUsSFRN
-TFZpZGVvRWxlbWVudDp0cnVlLEhUTUxEaXJlY3RvcnlFbGVtZW50OnRydWUsSFRNTEZvbnRFbGVtZW50
-OnRydWUsSFRNTEZyYW1lRWxlbWVudDp0cnVlLEhUTUxGcmFtZVNldEVsZW1lbnQ6dHJ1ZSxIVE1MTWFy
-cXVlZUVsZW1lbnQ6dHJ1ZSxIVE1MRWxlbWVudDpmYWxzZSxIVE1MQW5jaG9yRWxlbWVudDp0cnVlLEhU
-TUxBcmVhRWxlbWVudDp0cnVlLEhUTUxCYXNlRWxlbWVudDp0cnVlLEJsb2I6ZmFsc2UsSFRNTEJvZHlF
-bGVtZW50OnRydWUsQ0RBVEFTZWN0aW9uOnRydWUsQ2hhcmFjdGVyRGF0YTp0cnVlLENvbW1lbnQ6dHJ1
-ZSxQcm9jZXNzaW5nSW5zdHJ1Y3Rpb246dHJ1ZSxUZXh0OnRydWUsQ1NTU3R5bGVEZWNsYXJhdGlvbjp0
-cnVlLE1TU3R5bGVDU1NQcm9wZXJ0aWVzOnRydWUsQ1NTMlByb3BlcnRpZXM6dHJ1ZSxYTUxEb2N1bWVu
-dDp0cnVlLERvY3VtZW50OmZhbHNlLERPTUV4Y2VwdGlvbjp0cnVlLERPTUltcGxlbWVudGF0aW9uOnRy
-dWUsRE9NUmVjdFJlYWRPbmx5OmZhbHNlLERPTVRva2VuTGlzdDp0cnVlLEVsZW1lbnQ6ZmFsc2UsQWJv
-cnRQYXltZW50RXZlbnQ6dHJ1ZSxBbmltYXRpb25FdmVudDp0cnVlLEFuaW1hdGlvblBsYXliYWNrRXZl
-bnQ6dHJ1ZSxBcHBsaWNhdGlvbkNhY2hlRXJyb3JFdmVudDp0cnVlLEJhY2tncm91bmRGZXRjaENsaWNr
-RXZlbnQ6dHJ1ZSxCYWNrZ3JvdW5kRmV0Y2hFdmVudDp0cnVlLEJhY2tncm91bmRGZXRjaEZhaWxFdmVu
-dDp0cnVlLEJhY2tncm91bmRGZXRjaGVkRXZlbnQ6dHJ1ZSxCZWZvcmVJbnN0YWxsUHJvbXB0RXZlbnQ6
-dHJ1ZSxCZWZvcmVVbmxvYWRFdmVudDp0cnVlLEJsb2JFdmVudDp0cnVlLENhbk1ha2VQYXltZW50RXZl
-bnQ6dHJ1ZSxDbGlwYm9hcmRFdmVudDp0cnVlLENsb3NlRXZlbnQ6dHJ1ZSxDdXN0b21FdmVudDp0cnVl
-LERldmljZU1vdGlvbkV2ZW50OnRydWUsRGV2aWNlT3JpZW50YXRpb25FdmVudDp0cnVlLEVycm9yRXZl
-bnQ6dHJ1ZSxFeHRlbmRhYmxlRXZlbnQ6dHJ1ZSxFeHRlbmRhYmxlTWVzc2FnZUV2ZW50OnRydWUsRmV0
-Y2hFdmVudDp0cnVlLEZvbnRGYWNlU2V0TG9hZEV2ZW50OnRydWUsRm9yZWlnbkZldGNoRXZlbnQ6dHJ1
-ZSxHYW1lcGFkRXZlbnQ6dHJ1ZSxIYXNoQ2hhbmdlRXZlbnQ6dHJ1ZSxJbnN0YWxsRXZlbnQ6dHJ1ZSxN
-ZWRpYUVuY3J5cHRlZEV2ZW50OnRydWUsTWVkaWFLZXlNZXNzYWdlRXZlbnQ6dHJ1ZSxNZWRpYVF1ZXJ5
-TGlzdEV2ZW50OnRydWUsTWVkaWFTdHJlYW1FdmVudDp0cnVlLE1lZGlhU3RyZWFtVHJhY2tFdmVudDp0
-cnVlLE1lc3NhZ2VFdmVudDp0cnVlLE1JRElDb25uZWN0aW9uRXZlbnQ6dHJ1ZSxNSURJTWVzc2FnZUV2
-ZW50OnRydWUsTXV0YXRpb25FdmVudDp0cnVlLE5vdGlmaWNhdGlvbkV2ZW50OnRydWUsUGFnZVRyYW5z
-aXRpb25FdmVudDp0cnVlLFBheW1lbnRSZXF1ZXN0RXZlbnQ6dHJ1ZSxQYXltZW50UmVxdWVzdFVwZGF0
-ZUV2ZW50OnRydWUsUG9wU3RhdGVFdmVudDp0cnVlLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25BdmFpbGFi
-bGVFdmVudDp0cnVlLFByZXNlbnRhdGlvbkNvbm5lY3Rpb25DbG9zZUV2ZW50OnRydWUsUHJvbWlzZVJl
-amVjdGlvbkV2ZW50OnRydWUsUHVzaEV2ZW50OnRydWUsUlRDRGF0YUNoYW5uZWxFdmVudDp0cnVlLFJU
-Q0RUTUZUb25lQ2hhbmdlRXZlbnQ6dHJ1ZSxSVENQZWVyQ29ubmVjdGlvbkljZUV2ZW50OnRydWUsUlRD
-VHJhY2tFdmVudDp0cnVlLFNlY3VyaXR5UG9saWN5VmlvbGF0aW9uRXZlbnQ6dHJ1ZSxTZW5zb3JFcnJv
-ckV2ZW50OnRydWUsU3BlZWNoUmVjb2duaXRpb25FcnJvcjp0cnVlLFNwZWVjaFJlY29nbml0aW9uRXZl
-bnQ6dHJ1ZSxTcGVlY2hTeW50aGVzaXNFdmVudDp0cnVlLFN0b3JhZ2VFdmVudDp0cnVlLFN5bmNFdmVu
-dDp0cnVlLFRyYWNrRXZlbnQ6dHJ1ZSxUcmFuc2l0aW9uRXZlbnQ6dHJ1ZSxXZWJLaXRUcmFuc2l0aW9u
-RXZlbnQ6dHJ1ZSxWUkRldmljZUV2ZW50OnRydWUsVlJEaXNwbGF5RXZlbnQ6dHJ1ZSxWUlNlc3Npb25F
-dmVudDp0cnVlLE1vam9JbnRlcmZhY2VSZXF1ZXN0RXZlbnQ6dHJ1ZSxVU0JDb25uZWN0aW9uRXZlbnQ6
-dHJ1ZSxJREJWZXJzaW9uQ2hhbmdlRXZlbnQ6dHJ1ZSxBdWRpb1Byb2Nlc3NpbmdFdmVudDp0cnVlLE9m
-ZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudDp0cnVlLFdlYkdMQ29udGV4dEV2ZW50OnRydWUsRXZlbnQ6
-ZmFsc2UsSW5wdXRFdmVudDpmYWxzZSxTdWJtaXRFdmVudDpmYWxzZSxFdmVudFRhcmdldDpmYWxzZSxG
-aWxlOnRydWUsSFRNTEZvcm1FbGVtZW50OnRydWUsSGlzdG9yeTp0cnVlLEhUTUxEb2N1bWVudDp0cnVl
-LFhNTEh0dHBSZXF1ZXN0OnRydWUsWE1MSHR0cFJlcXVlc3RFdmVudFRhcmdldDpmYWxzZSxJbWFnZURh
-dGE6dHJ1ZSxMb2NhdGlvbjp0cnVlLE1vdXNlRXZlbnQ6dHJ1ZSxEcmFnRXZlbnQ6dHJ1ZSxQb2ludGVy
-RXZlbnQ6dHJ1ZSxXaGVlbEV2ZW50OnRydWUsRG9jdW1lbnRGcmFnbWVudDp0cnVlLFNoYWRvd1Jvb3Q6
-dHJ1ZSxEb2N1bWVudFR5cGU6dHJ1ZSxOb2RlOmZhbHNlLE5vZGVMaXN0OnRydWUsUmFkaW9Ob2RlTGlz
-dDp0cnVlLEhUTUxQYXJhZ3JhcGhFbGVtZW50OnRydWUsUHJvZ3Jlc3NFdmVudDp0cnVlLFJlc291cmNl
-UHJvZ3Jlc3NFdmVudDp0cnVlLEhUTUxTZWxlY3RFbGVtZW50OnRydWUsSFRNTFRhYmxlRWxlbWVudDp0
-cnVlLEhUTUxUYWJsZVJvd0VsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVTZWN0aW9uRWxlbWVudDp0cnVlLEhU
-TUxUZW1wbGF0ZUVsZW1lbnQ6dHJ1ZSxDb21wb3NpdGlvbkV2ZW50OnRydWUsRm9jdXNFdmVudDp0cnVl
-LEtleWJvYXJkRXZlbnQ6dHJ1ZSxUZXh0RXZlbnQ6dHJ1ZSxUb3VjaEV2ZW50OnRydWUsVUlFdmVudDpm
-YWxzZSxXaW5kb3c6dHJ1ZSxET01XaW5kb3c6dHJ1ZSxEZWRpY2F0ZWRXb3JrZXJHbG9iYWxTY29wZTp0
-cnVlLFNlcnZpY2VXb3JrZXJHbG9iYWxTY29wZTp0cnVlLFNoYXJlZFdvcmtlckdsb2JhbFNjb3BlOnRy
-dWUsV29ya2VyR2xvYmFsU2NvcGU6dHJ1ZSxBdHRyOnRydWUsQ2xpZW50UmVjdDp0cnVlLERPTVJlY3Q6
-dHJ1ZSxOYW1lZE5vZGVNYXA6dHJ1ZSxNb3pOYW1lZEF0dHJNYXA6dHJ1ZSxJREJLZXlSYW5nZTp0cnVl
-LFNWR1NjcmlwdEVsZW1lbnQ6dHJ1ZSxTVkdBRWxlbWVudDp0cnVlLFNWR0FuaW1hdGVFbGVtZW50OnRy
-dWUsU1ZHQW5pbWF0ZU1vdGlvbkVsZW1lbnQ6dHJ1ZSxTVkdBbmltYXRlVHJhbnNmb3JtRWxlbWVudDp0
-cnVlLFNWR0FuaW1hdGlvbkVsZW1lbnQ6dHJ1ZSxTVkdDaXJjbGVFbGVtZW50OnRydWUsU1ZHQ2xpcFBh
-dGhFbGVtZW50OnRydWUsU1ZHRGVmc0VsZW1lbnQ6dHJ1ZSxTVkdEZXNjRWxlbWVudDp0cnVlLFNWR0Rp
-c2NhcmRFbGVtZW50OnRydWUsU1ZHRWxsaXBzZUVsZW1lbnQ6dHJ1ZSxTVkdGRUJsZW5kRWxlbWVudDp0
-cnVlLFNWR0ZFQ29sb3JNYXRyaXhFbGVtZW50OnRydWUsU1ZHRkVDb21wb25lbnRUcmFuc2ZlckVsZW1l
-bnQ6dHJ1ZSxTVkdGRUNvbXBvc2l0ZUVsZW1lbnQ6dHJ1ZSxTVkdGRUNvbnZvbHZlTWF0cml4RWxlbWVu
-dDp0cnVlLFNWR0ZFRGlmZnVzZUxpZ2h0aW5nRWxlbWVudDp0cnVlLFNWR0ZFRGlzcGxhY2VtZW50TWFw
-RWxlbWVudDp0cnVlLFNWR0ZFRGlzdGFudExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFRmxvb2RFbGVtZW50
-OnRydWUsU1ZHRkVGdW5jQUVsZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNCRWxlbWVudDp0cnVlLFNWR0ZFRnVu
-Y0dFbGVtZW50OnRydWUsU1ZHRkVGdW5jUkVsZW1lbnQ6dHJ1ZSxTVkdGRUdhdXNzaWFuQmx1ckVsZW1l
-bnQ6dHJ1ZSxTVkdGRUltYWdlRWxlbWVudDp0cnVlLFNWR0ZFTWVyZ2VFbGVtZW50OnRydWUsU1ZHRkVN
-ZXJnZU5vZGVFbGVtZW50OnRydWUsU1ZHRkVNb3JwaG9sb2d5RWxlbWVudDp0cnVlLFNWR0ZFT2Zmc2V0
-RWxlbWVudDp0cnVlLFNWR0ZFUG9pbnRMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVNwZWN1bGFyTGlnaHRp
-bmdFbGVtZW50OnRydWUsU1ZHRkVTcG90TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVUaWxlRWxlbWVudDp0
-cnVlLFNWR0ZFVHVyYnVsZW5jZUVsZW1lbnQ6dHJ1ZSxTVkdGaWx0ZXJFbGVtZW50OnRydWUsU1ZHRm9y
-ZWlnbk9iamVjdEVsZW1lbnQ6dHJ1ZSxTVkdHRWxlbWVudDp0cnVlLFNWR0dlb21ldHJ5RWxlbWVudDp0
-cnVlLFNWR0dyYXBoaWNzRWxlbWVudDp0cnVlLFNWR0ltYWdlRWxlbWVudDp0cnVlLFNWR0xpbmVFbGVt
-ZW50OnRydWUsU1ZHTGluZWFyR3JhZGllbnRFbGVtZW50OnRydWUsU1ZHTWFya2VyRWxlbWVudDp0cnVl
-LFNWR01hc2tFbGVtZW50OnRydWUsU1ZHTWV0YWRhdGFFbGVtZW50OnRydWUsU1ZHUGF0aEVsZW1lbnQ6
-dHJ1ZSxTVkdQYXR0ZXJuRWxlbWVudDp0cnVlLFNWR1BvbHlnb25FbGVtZW50OnRydWUsU1ZHUG9seWxp
-bmVFbGVtZW50OnRydWUsU1ZHUmFkaWFsR3JhZGllbnRFbGVtZW50OnRydWUsU1ZHUmVjdEVsZW1lbnQ6
-dHJ1ZSxTVkdTZXRFbGVtZW50OnRydWUsU1ZHU3RvcEVsZW1lbnQ6dHJ1ZSxTVkdTdHlsZUVsZW1lbnQ6
-dHJ1ZSxTVkdTVkdFbGVtZW50OnRydWUsU1ZHU3dpdGNoRWxlbWVudDp0cnVlLFNWR1N5bWJvbEVsZW1l
-bnQ6dHJ1ZSxTVkdUU3BhbkVsZW1lbnQ6dHJ1ZSxTVkdUZXh0Q29udGVudEVsZW1lbnQ6dHJ1ZSxTVkdU
-ZXh0RWxlbWVudDp0cnVlLFNWR1RleHRQYXRoRWxlbWVudDp0cnVlLFNWR1RleHRQb3NpdGlvbmluZ0Vs
-ZW1lbnQ6dHJ1ZSxTVkdUaXRsZUVsZW1lbnQ6dHJ1ZSxTVkdVc2VFbGVtZW50OnRydWUsU1ZHVmlld0Vs
-ZW1lbnQ6dHJ1ZSxTVkdHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdDb21wb25lbnRUcmFuc2ZlckZ1bmN0
-aW9uRWxlbWVudDp0cnVlLFNWR0ZFRHJvcFNoYWRvd0VsZW1lbnQ6dHJ1ZSxTVkdNUGF0aEVsZW1lbnQ6
-dHJ1ZSxTVkdFbGVtZW50OmZhbHNlfSkKSC5MWi4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZm
-ZXJWaWV3IgpILlJHLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXciCkguVlAuJG5h
-dGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5EZy4kbmF0aXZlU3VwZXJjbGFzc1Rh
-Zz0iQXJyYXlCdWZmZXJWaWV3IgpILldCLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZp
-ZXciCkguWkcuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5QZy4kbmF0aXZl
-U3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3In0pKCkKY29udmVydEFsbFRvRmFzdE9iamVjdCh3
-KQpjb252ZXJ0VG9GYXN0T2JqZWN0KCQpOyhmdW5jdGlvbihhKXtpZih0eXBlb2YgZG9jdW1lbnQ9PT0i
-dW5kZWZpbmVkIil7YShudWxsKQpyZXR1cm59aWYodHlwZW9mIGRvY3VtZW50LmN1cnJlbnRTY3JpcHQh
-PSd1bmRlZmluZWQnKXthKGRvY3VtZW50LmN1cnJlbnRTY3JpcHQpCnJldHVybn12YXIgcz1kb2N1bWVu
-dC5zY3JpcHRzCmZ1bmN0aW9uIG9uTG9hZChiKXtmb3IodmFyIHE9MDtxPHMubGVuZ3RoOysrcSlzW3Fd
-LnJlbW92ZUV2ZW50TGlzdGVuZXIoImxvYWQiLG9uTG9hZCxmYWxzZSkKYShiLnRhcmdldCl9Zm9yKHZh
-ciByPTA7cjxzLmxlbmd0aDsrK3Ipc1tyXS5hZGRFdmVudExpc3RlbmVyKCJsb2FkIixvbkxvYWQsZmFs
-c2UpfSkoZnVuY3Rpb24oYSl7di5jdXJyZW50U2NyaXB0PWEKaWYodHlwZW9mIGRhcnRNYWluUnVubmVy
-PT09ImZ1bmN0aW9uIilkYXJ0TWFpblJ1bm5lcihMLklxLFtdKQplbHNlIEwuSXEoW10pfSl9KSgpCi8v
-IyBzb3VyY2VNYXBwaW5nVVJMPW1pZ3JhdGlvbi5qcy5tYXAK
+ZXJBZ2VudCA6ICIiOwogIGlmICh1c2VyQWdlbnQuaW5kZXhPZigiRmlyZWZveCIpID09IC0xKSByZXR1
+cm4gaG9va3M7CiAgdmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAg
+ICAiQmVmb3JlVW5sb2FkRXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9h
+cmQiLAogICAgIkdlb0dlb2xvY2F0aW9uIjogIkdlb2xvY2F0aW9uIiwKICAgICJMb2NhdGlvbiI6ICIh
+TG9jYXRpb24iLAogICAgIldvcmtlck1lc3NhZ2VFdmVudCI6ICJNZXNzYWdlRXZlbnQiLAogICAgIlhN
+TERvY3VtZW50IjogIiFEb2N1bWVudCJ9OwogIGZ1bmN0aW9uIGdldFRhZ0ZpcmVmb3gobykgewogICAg
+dmFyIHRhZyA9IGdldFRhZyhvKTsKICAgIHJldHVybiBxdWlja01hcFt0YWddIHx8IHRhZzsKICB9CiAg
+aG9va3MuZ2V0VGFnID0gZ2V0VGFnRmlyZWZveDsKfQpDLnhpPWZ1bmN0aW9uKGhvb2tzKSB7CiAgdmFy
+IHVzZXJBZ2VudCA9IHR5cGVvZiBuYXZpZ2F0b3IgPT0gIm9iamVjdCIgPyBuYXZpZ2F0b3IudXNlckFn
+ZW50IDogIiI7CiAgaWYgKHVzZXJBZ2VudC5pbmRleE9mKCJUcmlkZW50LyIpID09IC0xKSByZXR1cm4g
+aG9va3M7CiAgdmFyIGdldFRhZyA9IGhvb2tzLmdldFRhZzsKICB2YXIgcXVpY2tNYXAgPSB7CiAgICAi
+QmVmb3JlVW5sb2FkRXZlbnQiOiAiRXZlbnQiLAogICAgIkRhdGFUcmFuc2ZlciI6ICJDbGlwYm9hcmQi
+LAogICAgIkhUTUxEREVsZW1lbnQiOiAiSFRNTEVsZW1lbnQiLAogICAgIkhUTUxEVEVsZW1lbnQiOiAi
+SFRNTEVsZW1lbnQiLAogICAgIkhUTUxQaHJhc2VFbGVtZW50IjogIkhUTUxFbGVtZW50IiwKICAgICJQ
+b3NpdGlvbiI6ICJHZW9wb3NpdGlvbiIKICB9OwogIGZ1bmN0aW9uIGdldFRhZ0lFKG8pIHsKICAgIHZh
+ciB0YWcgPSBnZXRUYWcobyk7CiAgICB2YXIgbmV3VGFnID0gcXVpY2tNYXBbdGFnXTsKICAgIGlmIChu
+ZXdUYWcpIHJldHVybiBuZXdUYWc7CiAgICBpZiAodGFnID09ICJPYmplY3QiKSB7CiAgICAgIGlmICh3
+aW5kb3cuRGF0YVZpZXcgJiYgKG8gaW5zdGFuY2VvZiB3aW5kb3cuRGF0YVZpZXcpKSByZXR1cm4gIkRh
+dGFWaWV3IjsKICAgIH0KICAgIHJldHVybiB0YWc7CiAgfQogIGZ1bmN0aW9uIHByb3RvdHlwZUZvclRh
+Z0lFKHRhZykgewogICAgdmFyIGNvbnN0cnVjdG9yID0gd2luZG93W3RhZ107CiAgICBpZiAoY29uc3Ry
+dWN0b3IgPT0gbnVsbCkgcmV0dXJuIG51bGw7CiAgICByZXR1cm4gY29uc3RydWN0b3IucHJvdG90eXBl
+OwogIH0KICBob29rcy5nZXRUYWcgPSBnZXRUYWdJRTsKICBob29rcy5wcm90b3R5cGVGb3JUYWcgPSBw
+cm90b3R5cGVGb3JUYWdJRTsKfQpDLmk3PWZ1bmN0aW9uKGhvb2tzKSB7IHJldHVybiBob29rczsgfQoK
+Qy5DdD1uZXcgUC5ieSgpCkMuRXE9bmV3IFAuazUoKQpDLnhNPW5ldyBQLnU1KCkKQy5Raz1uZXcgUC5F
+MygpCkMuTnY9bmV3IEgua3IoKQpDLk5VPW5ldyBQLkppKCkKQy5wZD1uZXcgUC5aZCgpCkMuQWQ9bmV3
+IE0uSDcoMCwiSGludEFjdGlvbktpbmQuYWRkTnVsbGFibGVIaW50IikKQy5uZT1uZXcgTS5INygxLCJI
+aW50QWN0aW9uS2luZC5hZGROb25OdWxsYWJsZUhpbnQiKQpDLm15PW5ldyBNLkg3KDIsIkhpbnRBY3Rp
+b25LaW5kLmNoYW5nZVRvTnVsbGFibGVIaW50IikKQy5yeD1uZXcgTS5INygzLCJIaW50QWN0aW9uS2lu
+ZC5jaGFuZ2VUb05vbk51bGxhYmxlSGludCIpCkMud1Y9bmV3IE0uSDcoNCwiSGludEFjdGlvbktpbmQu
+cmVtb3ZlTnVsbGFibGVIaW50IikKQy5mUj1uZXcgTS5INyg1LCJIaW50QWN0aW9uS2luZC5yZW1vdmVO
+b25OdWxsYWJsZUhpbnQiKQpDLkEzPW5ldyBQLk14KG51bGwpCkMublg9bmV3IFAub2oobnVsbCkKQy5j
+dz1uZXcgTC5HYigwLCJVbml0TWlncmF0aW9uU3RhdHVzLmFscmVhZHlNaWdyYXRlZCIpCkMuZGM9bmV3
+IEwuR2IoMSwiVW5pdE1pZ3JhdGlvblN0YXR1cy5pbmRldGVybWluYXRlIikKQy5XRD1uZXcgTC5HYigy
+LCJVbml0TWlncmF0aW9uU3RhdHVzLm1pZ3JhdGluZyIpCkMuWGo9bmV3IEwuR2IoMywiVW5pdE1pZ3Jh
+dGlvblN0YXR1cy5vcHRpbmdPdXQiKQpDLmwwPUguVk0ocyhbQy5jdyxDLmRjLEMuV0QsQy5Yal0pLEgu
+TjAoImpkPEdiKj4iKSkKQy5haz1ILlZNKHMoWzAsMCwzMjc3NiwzMzc5MiwxLDEwMjQwLDAsMF0pLHQu
+VikKQy5jbT1ILlZNKHMoWyIqOjpjbGFzcyIsIio6OmRpciIsIio6OmRyYWdnYWJsZSIsIio6OmhpZGRl
+biIsIio6OmlkIiwiKjo6aW5lcnQiLCIqOjppdGVtcHJvcCIsIio6Oml0ZW1yZWYiLCIqOjppdGVtc2Nv
+cGUiLCIqOjpsYW5nIiwiKjo6c3BlbGxjaGVjayIsIio6OnRpdGxlIiwiKjo6dHJhbnNsYXRlIiwiQTo6
+YWNjZXNza2V5IiwiQTo6Y29vcmRzIiwiQTo6aHJlZmxhbmciLCJBOjpuYW1lIiwiQTo6c2hhcGUiLCJB
+Ojp0YWJpbmRleCIsIkE6OnRhcmdldCIsIkE6OnR5cGUiLCJBUkVBOjphY2Nlc3NrZXkiLCJBUkVBOjph
+bHQiLCJBUkVBOjpjb29yZHMiLCJBUkVBOjpub2hyZWYiLCJBUkVBOjpzaGFwZSIsIkFSRUE6OnRhYmlu
+ZGV4IiwiQVJFQTo6dGFyZ2V0IiwiQVVESU86OmNvbnRyb2xzIiwiQVVESU86Omxvb3AiLCJBVURJTzo6
+bWVkaWFncm91cCIsIkFVRElPOjptdXRlZCIsIkFVRElPOjpwcmVsb2FkIiwiQkRPOjpkaXIiLCJCT0RZ
+OjphbGluayIsIkJPRFk6OmJnY29sb3IiLCJCT0RZOjpsaW5rIiwiQk9EWTo6dGV4dCIsIkJPRFk6OnZs
+aW5rIiwiQlI6OmNsZWFyIiwiQlVUVE9OOjphY2Nlc3NrZXkiLCJCVVRUT046OmRpc2FibGVkIiwiQlVU
+VE9OOjpuYW1lIiwiQlVUVE9OOjp0YWJpbmRleCIsIkJVVFRPTjo6dHlwZSIsIkJVVFRPTjo6dmFsdWUi
+LCJDQU5WQVM6OmhlaWdodCIsIkNBTlZBUzo6d2lkdGgiLCJDQVBUSU9OOjphbGlnbiIsIkNPTDo6YWxp
+Z24iLCJDT0w6OmNoYXIiLCJDT0w6OmNoYXJvZmYiLCJDT0w6OnNwYW4iLCJDT0w6OnZhbGlnbiIsIkNP
+TDo6d2lkdGgiLCJDT0xHUk9VUDo6YWxpZ24iLCJDT0xHUk9VUDo6Y2hhciIsIkNPTEdST1VQOjpjaGFy
+b2ZmIiwiQ09MR1JPVVA6OnNwYW4iLCJDT0xHUk9VUDo6dmFsaWduIiwiQ09MR1JPVVA6OndpZHRoIiwi
+Q09NTUFORDo6Y2hlY2tlZCIsIkNPTU1BTkQ6OmNvbW1hbmQiLCJDT01NQU5EOjpkaXNhYmxlZCIsIkNP
+TU1BTkQ6OmxhYmVsIiwiQ09NTUFORDo6cmFkaW9ncm91cCIsIkNPTU1BTkQ6OnR5cGUiLCJEQVRBOjp2
+YWx1ZSIsIkRFTDo6ZGF0ZXRpbWUiLCJERVRBSUxTOjpvcGVuIiwiRElSOjpjb21wYWN0IiwiRElWOjph
+bGlnbiIsIkRMOjpjb21wYWN0IiwiRklFTERTRVQ6OmRpc2FibGVkIiwiRk9OVDo6Y29sb3IiLCJGT05U
+OjpmYWNlIiwiRk9OVDo6c2l6ZSIsIkZPUk06OmFjY2VwdCIsIkZPUk06OmF1dG9jb21wbGV0ZSIsIkZP
+Uk06OmVuY3R5cGUiLCJGT1JNOjptZXRob2QiLCJGT1JNOjpuYW1lIiwiRk9STTo6bm92YWxpZGF0ZSIs
+IkZPUk06OnRhcmdldCIsIkZSQU1FOjpuYW1lIiwiSDE6OmFsaWduIiwiSDI6OmFsaWduIiwiSDM6OmFs
+aWduIiwiSDQ6OmFsaWduIiwiSDU6OmFsaWduIiwiSDY6OmFsaWduIiwiSFI6OmFsaWduIiwiSFI6Om5v
+c2hhZGUiLCJIUjo6c2l6ZSIsIkhSOjp3aWR0aCIsIkhUTUw6OnZlcnNpb24iLCJJRlJBTUU6OmFsaWdu
+IiwiSUZSQU1FOjpmcmFtZWJvcmRlciIsIklGUkFNRTo6aGVpZ2h0IiwiSUZSQU1FOjptYXJnaW5oZWln
+aHQiLCJJRlJBTUU6Om1hcmdpbndpZHRoIiwiSUZSQU1FOjp3aWR0aCIsIklNRzo6YWxpZ24iLCJJTUc6
+OmFsdCIsIklNRzo6Ym9yZGVyIiwiSU1HOjpoZWlnaHQiLCJJTUc6OmhzcGFjZSIsIklNRzo6aXNtYXAi
+LCJJTUc6Om5hbWUiLCJJTUc6OnVzZW1hcCIsIklNRzo6dnNwYWNlIiwiSU1HOjp3aWR0aCIsIklOUFVU
+OjphY2NlcHQiLCJJTlBVVDo6YWNjZXNza2V5IiwiSU5QVVQ6OmFsaWduIiwiSU5QVVQ6OmFsdCIsIklO
+UFVUOjphdXRvY29tcGxldGUiLCJJTlBVVDo6YXV0b2ZvY3VzIiwiSU5QVVQ6OmNoZWNrZWQiLCJJTlBV
+VDo6ZGlzYWJsZWQiLCJJTlBVVDo6aW5wdXRtb2RlIiwiSU5QVVQ6OmlzbWFwIiwiSU5QVVQ6Omxpc3Qi
+LCJJTlBVVDo6bWF4IiwiSU5QVVQ6Om1heGxlbmd0aCIsIklOUFVUOjptaW4iLCJJTlBVVDo6bXVsdGlw
+bGUiLCJJTlBVVDo6bmFtZSIsIklOUFVUOjpwbGFjZWhvbGRlciIsIklOUFVUOjpyZWFkb25seSIsIklO
+UFVUOjpyZXF1aXJlZCIsIklOUFVUOjpzaXplIiwiSU5QVVQ6OnN0ZXAiLCJJTlBVVDo6dGFiaW5kZXgi
+LCJJTlBVVDo6dHlwZSIsIklOUFVUOjp1c2VtYXAiLCJJTlBVVDo6dmFsdWUiLCJJTlM6OmRhdGV0aW1l
+IiwiS0VZR0VOOjpkaXNhYmxlZCIsIktFWUdFTjo6a2V5dHlwZSIsIktFWUdFTjo6bmFtZSIsIkxBQkVM
+OjphY2Nlc3NrZXkiLCJMQUJFTDo6Zm9yIiwiTEVHRU5EOjphY2Nlc3NrZXkiLCJMRUdFTkQ6OmFsaWdu
+IiwiTEk6OnR5cGUiLCJMSTo6dmFsdWUiLCJMSU5LOjpzaXplcyIsIk1BUDo6bmFtZSIsIk1FTlU6OmNv
+bXBhY3QiLCJNRU5VOjpsYWJlbCIsIk1FTlU6OnR5cGUiLCJNRVRFUjo6aGlnaCIsIk1FVEVSOjpsb3ci
+LCJNRVRFUjo6bWF4IiwiTUVURVI6Om1pbiIsIk1FVEVSOjp2YWx1ZSIsIk9CSkVDVDo6dHlwZW11c3Rt
+YXRjaCIsIk9MOjpjb21wYWN0IiwiT0w6OnJldmVyc2VkIiwiT0w6OnN0YXJ0IiwiT0w6OnR5cGUiLCJP
+UFRHUk9VUDo6ZGlzYWJsZWQiLCJPUFRHUk9VUDo6bGFiZWwiLCJPUFRJT046OmRpc2FibGVkIiwiT1BU
+SU9OOjpsYWJlbCIsIk9QVElPTjo6c2VsZWN0ZWQiLCJPUFRJT046OnZhbHVlIiwiT1VUUFVUOjpmb3Ii
+LCJPVVRQVVQ6Om5hbWUiLCJQOjphbGlnbiIsIlBSRTo6d2lkdGgiLCJQUk9HUkVTUzo6bWF4IiwiUFJP
+R1JFU1M6Om1pbiIsIlBST0dSRVNTOjp2YWx1ZSIsIlNFTEVDVDo6YXV0b2NvbXBsZXRlIiwiU0VMRUNU
+OjpkaXNhYmxlZCIsIlNFTEVDVDo6bXVsdGlwbGUiLCJTRUxFQ1Q6Om5hbWUiLCJTRUxFQ1Q6OnJlcXVp
+cmVkIiwiU0VMRUNUOjpzaXplIiwiU0VMRUNUOjp0YWJpbmRleCIsIlNPVVJDRTo6dHlwZSIsIlRBQkxF
+OjphbGlnbiIsIlRBQkxFOjpiZ2NvbG9yIiwiVEFCTEU6OmJvcmRlciIsIlRBQkxFOjpjZWxscGFkZGlu
+ZyIsIlRBQkxFOjpjZWxsc3BhY2luZyIsIlRBQkxFOjpmcmFtZSIsIlRBQkxFOjpydWxlcyIsIlRBQkxF
+OjpzdW1tYXJ5IiwiVEFCTEU6OndpZHRoIiwiVEJPRFk6OmFsaWduIiwiVEJPRFk6OmNoYXIiLCJUQk9E
+WTo6Y2hhcm9mZiIsIlRCT0RZOjp2YWxpZ24iLCJURDo6YWJiciIsIlREOjphbGlnbiIsIlREOjpheGlz
+IiwiVEQ6OmJnY29sb3IiLCJURDo6Y2hhciIsIlREOjpjaGFyb2ZmIiwiVEQ6OmNvbHNwYW4iLCJURDo6
+aGVhZGVycyIsIlREOjpoZWlnaHQiLCJURDo6bm93cmFwIiwiVEQ6OnJvd3NwYW4iLCJURDo6c2NvcGUi
+LCJURDo6dmFsaWduIiwiVEQ6OndpZHRoIiwiVEVYVEFSRUE6OmFjY2Vzc2tleSIsIlRFWFRBUkVBOjph
+dXRvY29tcGxldGUiLCJURVhUQVJFQTo6Y29scyIsIlRFWFRBUkVBOjpkaXNhYmxlZCIsIlRFWFRBUkVB
+OjppbnB1dG1vZGUiLCJURVhUQVJFQTo6bmFtZSIsIlRFWFRBUkVBOjpwbGFjZWhvbGRlciIsIlRFWFRB
+UkVBOjpyZWFkb25seSIsIlRFWFRBUkVBOjpyZXF1aXJlZCIsIlRFWFRBUkVBOjpyb3dzIiwiVEVYVEFS
+RUE6OnRhYmluZGV4IiwiVEVYVEFSRUE6OndyYXAiLCJURk9PVDo6YWxpZ24iLCJURk9PVDo6Y2hhciIs
+IlRGT09UOjpjaGFyb2ZmIiwiVEZPT1Q6OnZhbGlnbiIsIlRIOjphYmJyIiwiVEg6OmFsaWduIiwiVEg6
+OmF4aXMiLCJUSDo6Ymdjb2xvciIsIlRIOjpjaGFyIiwiVEg6OmNoYXJvZmYiLCJUSDo6Y29sc3BhbiIs
+IlRIOjpoZWFkZXJzIiwiVEg6OmhlaWdodCIsIlRIOjpub3dyYXAiLCJUSDo6cm93c3BhbiIsIlRIOjpz
+Y29wZSIsIlRIOjp2YWxpZ24iLCJUSDo6d2lkdGgiLCJUSEVBRDo6YWxpZ24iLCJUSEVBRDo6Y2hhciIs
+IlRIRUFEOjpjaGFyb2ZmIiwiVEhFQUQ6OnZhbGlnbiIsIlRSOjphbGlnbiIsIlRSOjpiZ2NvbG9yIiwi
+VFI6OmNoYXIiLCJUUjo6Y2hhcm9mZiIsIlRSOjp2YWxpZ24iLCJUUkFDSzo6ZGVmYXVsdCIsIlRSQUNL
+OjpraW5kIiwiVFJBQ0s6OmxhYmVsIiwiVFJBQ0s6OnNyY2xhbmciLCJVTDo6Y29tcGFjdCIsIlVMOjp0
+eXBlIiwiVklERU86OmNvbnRyb2xzIiwiVklERU86OmhlaWdodCIsIlZJREVPOjpsb29wIiwiVklERU86
+Om1lZGlhZ3JvdXAiLCJWSURFTzo6bXV0ZWQiLCJWSURFTzo6cHJlbG9hZCIsIlZJREVPOjp3aWR0aCJd
+KSx0LmkpCkMuVkM9SC5WTShzKFswLDAsNjU0OTAsNDUwNTUsNjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFd
+KSx0LlYpCkMubUs9SC5WTShzKFswLDAsMjY2MjQsMTAyMyw2NTUzNCwyMDQ3LDY1NTM0LDIwNDddKSx0
+LlYpCkMuU3E9SC5WTShzKFsiSEVBRCIsIkFSRUEiLCJCQVNFIiwiQkFTRUZPTlQiLCJCUiIsIkNPTCIs
+IkNPTEdST1VQIiwiRU1CRUQiLCJGUkFNRSIsIkZSQU1FU0VUIiwiSFIiLCJJTUFHRSIsIklNRyIsIklO
+UFVUIiwiSVNJTkRFWCIsIkxJTksiLCJNRVRBIiwiUEFSQU0iLCJTT1VSQ0UiLCJTVFlMRSIsIlRJVExF
+IiwiV0JSIl0pLHQuaSkKQy5oVT1ILlZNKHMoW10pLHQuYikKQy5kbj1ILlZNKHMoW10pLEguTjAoImpk
+PExMKj4iKSkKQy54RD1ILlZNKHMoW10pLHQuaSkKQy50bz1ILlZNKHMoWzAsMCwzMjcyMiwxMjI4Nyw2
+NTUzNCwzNDgxNSw2NTUzNCwxODQzMV0pLHQuVikKQy5yaz1ILlZNKHMoW0MuQWQsQy5uZSxDLm15LEMu
+cngsQy53VixDLmZSXSksSC5OMCgiamQ8SDcqPiIpKQpDLkYzPUguVk0ocyhbMCwwLDI0NTc2LDEwMjMs
+NjU1MzQsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuZWE9SC5WTShzKFswLDAsMzI3NTQsMTEyNjMs
+NjU1MzQsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuWko9SC5WTShzKFswLDAsMzI3MjIsMTIyODcs
+NjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuV2Q9SC5WTShzKFswLDAsNjU0OTAsMTIyODcs
+NjU1MzUsMzQ4MTUsNjU1MzQsMTg0MzFdKSx0LlYpCkMuUXg9SC5WTShzKFsiYmluZCIsImlmIiwicmVm
+IiwicmVwZWF0Iiwic3ludGF4Il0pLHQuaSkKQy5CST1ILlZNKHMoWyJBOjpocmVmIiwiQVJFQTo6aHJl
+ZiIsIkJMT0NLUVVPVEU6OmNpdGUiLCJCT0RZOjpiYWNrZ3JvdW5kIiwiQ09NTUFORDo6aWNvbiIsIkRF
+TDo6Y2l0ZSIsIkZPUk06OmFjdGlvbiIsIklNRzo6c3JjIiwiSU5QVVQ6OnNyYyIsIklOUzo6Y2l0ZSIs
+IlE6OmNpdGUiLCJWSURFTzo6cG9zdGVyIl0pLHQuaSkKQy5EeD1uZXcgSC5MUCgwLHt9LEMueEQsSC5O
+MCgiTFA8cVUqLHpNPGo4Kj4qPiIpKQpDLkNNPW5ldyBILkxQKDAse30sQy54RCxILk4wKCJMUDxxVSos
+cVUqPiIpKQpDLmlIPUguVk0ocyhbXSksSC5OMCgiamQ8R0QqPiIpKQpDLldPPW5ldyBILkxQKDAse30s
+Qy5pSCxILk4wKCJMUDxHRCosQD4iKSkKQy5ZMj1uZXcgTC5POSgiTmF2aWdhdGlvblRyZWVOb2RlVHlw
+ZS5kaXJlY3RvcnkiKQpDLnJmPW5ldyBMLk85KCJOYXZpZ2F0aW9uVHJlZU5vZGVUeXBlLmZpbGUiKQpD
+LlRlPW5ldyBILnd2KCJjYWxsIikKQy5vRT1uZXcgUC5HWSghMSkKQy53UT1uZXcgUC5GeShudWxsLDIp
+fSkoKTsoZnVuY3Rpb24gc3RhdGljRmllbGRzKCl7JC56bT1udWxsCiQueWo9MAokLm1KPW51bGwKJC5Q
+ND1udWxsCiQuTkY9bnVsbAokLlRYPW51bGwKJC54Nz1udWxsCiQubnc9bnVsbAokLnZ2PW51bGwKJC5C
+dj1udWxsCiQuUzY9bnVsbAokLms4PW51bGwKJC5tZz1udWxsCiQuVUQ9ITEKJC5YMz1DLk5VCiQueGc9
+SC5WTShbXSxILk4wKCJqZDxNaD4iKSkKJC54bz1udWxsCiQuQk89bnVsbAokLmx0PW51bGwKJC5FVT1u
+dWxsCiQub3I9UC5GbCh0Lk4sdC5ZKQokLklSPW51bGwKJC5JNj1udWxsCiQuRmY9bnVsbH0pKCk7KGZ1
+bmN0aW9uIGxhenlJbml0aWFsaXplcnMoKXt2YXIgcz1odW5rSGVscGVycy5sYXp5RmluYWwscj1odW5r
+SGVscGVycy5sYXp5T2xkCnMoJCwiZmEiLCJ3IixmdW5jdGlvbigpe3JldHVybiBILllnKCJfJGRhcnRf
+ZGFydENsb3N1cmUiKX0pCnMoJCwiVTIiLCJTbiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHsK
+dG9TdHJpbmc6ZnVuY3Rpb24oKXtyZXR1cm4iJHJlY2VpdmVyJCJ9fSkpfSkKcygkLCJ4cSIsImxxIixm
+dW5jdGlvbigpe3JldHVybiBILmNNKEguUzcoeyRtZXRob2QkOm51bGwsCnRvU3RyaW5nOmZ1bmN0aW9u
+KCl7cmV0dXJuIiRyZWNlaXZlciQifX0pKX0pCnMoJCwiUjEiLCJOOSIsZnVuY3Rpb24oKXtyZXR1cm4g
+SC5jTShILlM3KG51bGwpKX0pCnMoJCwiZk4iLCJpSSIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5j
+dGlvbigpe3ZhciAkYXJndW1lbnRzRXhwciQ9JyRhcmd1bWVudHMkJwp0cnl7bnVsbC4kbWV0aG9kJCgk
+YXJndW1lbnRzRXhwciQpfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwicWkiLCJV
+TiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILlM3KHZvaWQgMCkpfSkKcygkLCJyWiIsIlpoIixmdW5j
+dGlvbigpe3JldHVybiBILmNNKGZ1bmN0aW9uKCl7dmFyICRhcmd1bWVudHNFeHByJD0nJGFyZ3VtZW50
+cyQnCnRyeXsodm9pZCAwKS4kbWV0aG9kJCgkYXJndW1lbnRzRXhwciQpfWNhdGNoKHEpe3JldHVybiBx
+Lm1lc3NhZ2V9fSgpKX0pCnMoJCwia3EiLCJyTiIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILk1qKG51
+bGwpKX0pCnMoJCwidHQiLCJjMyIsZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShmdW5jdGlvbigpe3RyeXtu
+dWxsLiRtZXRob2QkfWNhdGNoKHEpe3JldHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwiZHQiLCJISyIs
+ZnVuY3Rpb24oKXtyZXR1cm4gSC5jTShILk1qKHZvaWQgMCkpfSkKcygkLCJBNyIsInIxIixmdW5jdGlv
+bigpe3JldHVybiBILmNNKGZ1bmN0aW9uKCl7dHJ5eyh2b2lkIDApLiRtZXRob2QkfWNhdGNoKHEpe3Jl
+dHVybiBxLm1lc3NhZ2V9fSgpKX0pCnMoJCwiV2MiLCJ1dCIsZnVuY3Rpb24oKXtyZXR1cm4gUC5Paigp
+fSkKcygkLCJraCIsInJmIixmdW5jdGlvbigpe3JldHVybiBuZXcgUC54cigpLiQwKCl9KQpzKCQsImRI
+IiwiSEciLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBQLk56KCkuJDAoKX0pCnMoJCwiYnQiLCJWNyIsZnVu
+Y3Rpb24oKXtyZXR1cm4gbmV3IEludDhBcnJheShILlhGKEguVk0oWy0yLC0yLC0yLC0yLC0yLC0yLC0y
+LC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0y
+LC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0yLC0xLC0yLC0yLC0yLC0yLC0yLDYyLC0yLDYyLC0y
+LDYzLDUyLDUzLDU0LDU1LDU2LDU3LDU4LDU5LDYwLDYxLC0yLC0yLC0yLC0xLC0yLC0yLC0yLDAsMSwy
+LDMsNCw1LDYsNyw4LDksMTAsMTEsMTIsMTMsMTQsMTUsMTYsMTcsMTgsMTksMjAsMjEsMjIsMjMsMjQs
+MjUsLTIsLTIsLTIsLTIsNjMsLTIsMjYsMjcsMjgsMjksMzAsMzEsMzIsMzMsMzQsMzUsMzYsMzcsMzgs
+MzksNDAsNDEsNDIsNDMsNDQsNDUsNDYsNDcsNDgsNDksNTAsNTEsLTIsLTIsLTIsLTIsLTJdLHQuYSkp
+KX0pCnMoJCwiTTUiLCJ3USIsZnVuY3Rpb24oKXtyZXR1cm4gdHlwZW9mIHByb2Nlc3MhPSJ1bmRlZmlu
+ZWQiJiZPYmplY3QucHJvdG90eXBlLnRvU3RyaW5nLmNhbGwocHJvY2Vzcyk9PSJbb2JqZWN0IHByb2Nl
+c3NdIiYmcHJvY2Vzcy5wbGF0Zm9ybT09IndpbjMyIn0pCnMoJCwibWYiLCJ6NCIsZnVuY3Rpb24oKXty
+ZXR1cm4gUC5udSgiXltcXC1cXC4wLTlBLVpfYS16fl0qJCIpfSkKcygkLCJPUSIsInZaIixmdW5jdGlv
+bigpe3JldHVybiBQLktOKCl9KQpzKCQsIlNDIiwiQU4iLGZ1bmN0aW9uKCl7cmV0dXJuIFAudE0oWyJB
+IiwiQUJCUiIsIkFDUk9OWU0iLCJBRERSRVNTIiwiQVJFQSIsIkFSVElDTEUiLCJBU0lERSIsIkFVRElP
+IiwiQiIsIkJESSIsIkJETyIsIkJJRyIsIkJMT0NLUVVPVEUiLCJCUiIsIkJVVFRPTiIsIkNBTlZBUyIs
+IkNBUFRJT04iLCJDRU5URVIiLCJDSVRFIiwiQ09ERSIsIkNPTCIsIkNPTEdST1VQIiwiQ09NTUFORCIs
+IkRBVEEiLCJEQVRBTElTVCIsIkREIiwiREVMIiwiREVUQUlMUyIsIkRGTiIsIkRJUiIsIkRJViIsIkRM
+IiwiRFQiLCJFTSIsIkZJRUxEU0VUIiwiRklHQ0FQVElPTiIsIkZJR1VSRSIsIkZPTlQiLCJGT09URVIi
+LCJGT1JNIiwiSDEiLCJIMiIsIkgzIiwiSDQiLCJINSIsIkg2IiwiSEVBREVSIiwiSEdST1VQIiwiSFIi
+LCJJIiwiSUZSQU1FIiwiSU1HIiwiSU5QVVQiLCJJTlMiLCJLQkQiLCJMQUJFTCIsIkxFR0VORCIsIkxJ
+IiwiTUFQIiwiTUFSSyIsIk1FTlUiLCJNRVRFUiIsIk5BViIsIk5PQlIiLCJPTCIsIk9QVEdST1VQIiwi
+T1BUSU9OIiwiT1VUUFVUIiwiUCIsIlBSRSIsIlBST0dSRVNTIiwiUSIsIlMiLCJTQU1QIiwiU0VDVElP
+TiIsIlNFTEVDVCIsIlNNQUxMIiwiU09VUkNFIiwiU1BBTiIsIlNUUklLRSIsIlNUUk9ORyIsIlNVQiIs
+IlNVTU1BUlkiLCJTVVAiLCJUQUJMRSIsIlRCT0RZIiwiVEQiLCJURVhUQVJFQSIsIlRGT09UIiwiVEgi
+LCJUSEVBRCIsIlRJTUUiLCJUUiIsIlRSQUNLIiwiVFQiLCJVIiwiVUwiLCJWQVIiLCJWSURFTyIsIldC
+UiJdLHQuTil9KQpzKCQsIlg0IiwiaEciLGZ1bmN0aW9uKCl7cmV0dXJuIFAubnUoIl5cXFMrJCIpfSkK
+cygkLCJ3TyIsIm93IixmdW5jdGlvbigpe3JldHVybiBQLk5EKHNlbGYpfSkKcygkLCJrdCIsIlI4Iixm
+dW5jdGlvbigpe3JldHVybiBILllnKCJfJGRhcnRfZGFydE9iamVjdCIpfSkKcygkLCJmSyIsImtJIixm
+dW5jdGlvbigpe3JldHVybiBmdW5jdGlvbiBEYXJ0T2JqZWN0KGEpe3RoaXMubz1hfX0pCnIoJCwicXQi
+LCJ6QiIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IFQubVEoKX0pCnIoJCwiT2wiLCJVRSIsZnVuY3Rpb24o
+KXtyZXR1cm4gUC5oSyhDLm9sLmdtVyhXLngzKCkpLmhyZWYpLmdoWSgpLnEoMCwiYXV0aFRva2VuIil9
+KQpyKCQsImhUIiwieVAiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCIuZWRp
+dC1saXN0IC5wYW5lbC1jb250ZW50Iil9KQpyKCQsIlc2IiwiaEwiLGZ1bmN0aW9uKCl7cmV0dXJuIFcu
+WnIoKS5xdWVyeVNlbGVjdG9yKCIuZWRpdC1wYW5lbCAucGFuZWwtY29udGVudCIpfSkKcigkLCJUUiIs
+IkRXIixmdW5jdGlvbigpe3JldHVybiBXLlpyKCkucXVlcnlTZWxlY3RvcigiZm9vdGVyIil9KQpyKCQs
+IkVZIiwiZmkiLGZ1bmN0aW9uKCl7cmV0dXJuIFcuWnIoKS5xdWVyeVNlbGVjdG9yKCJoZWFkZXIiKX0p
+CnIoJCwiYXYiLCJEOSIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiN1bml0
+LW5hbWUiKX0pCnIoJCwidDAiLCJiTiIsZnVuY3Rpb24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0
+b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24tbGFiZWwiKX0pCnIoJCwiYkEiLCJjMCIsZnVuY3Rp
+b24oKXtyZXR1cm4gVy5acigpLnF1ZXJ5U2VsZWN0b3IoIiNtaWdyYXRlLXVuaXQtc3RhdHVzLWljb24i
+KX0pCnIoJCwiZmUiLCJLRyIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IEwuWEEoKX0pCnMoJCwiZW8iLCJu
+VSIsZnVuY3Rpb24oKXtyZXR1cm4gbmV3IE0ubEkoJC5IaygpKX0pCnMoJCwieXIiLCJiRCIsZnVuY3Rp
+b24oKXtyZXR1cm4gbmV3IEUuT0YoUC5udSgiLyIpLFAubnUoIlteL10kIiksUC5udSgiXi8iKSl9KQpz
+KCQsIk1rIiwiS2siLGZ1bmN0aW9uKCl7cmV0dXJuIG5ldyBMLklWKFAubnUoIlsvXFxcXF0iKSxQLm51
+KCJbXi9cXFxcXSQiKSxQLm51KCJeKFxcXFxcXFxcW15cXFxcXStcXFxcW15cXFxcL10rfFthLXpBLVpd
+OlsvXFxcXF0pIiksUC5udSgiXlsvXFxcXF0oPyFbL1xcXFxdKSIpKX0pCnMoJCwiYWsiLCJFYiIsZnVu
+Y3Rpb24oKXtyZXR1cm4gbmV3IEYucnUoUC5udSgiLyIpLFAubnUoIiheW2EtekEtWl1bLSsuYS16QS1a
+XFxkXSo6Ly98W14vXSkkIiksUC5udSgiW2EtekEtWl1bLSsuYS16QS1aXFxkXSo6Ly9bXi9dKiIpLFAu
+bnUoIl4vIikpfSkKcygkLCJscyIsIkhrIixmdW5jdGlvbigpe3JldHVybiBPLlJoKCl9KX0pKCk7KGZ1
+bmN0aW9uIG5hdGl2ZVN1cHBvcnQoKXshZnVuY3Rpb24oKXt2YXIgcz1mdW5jdGlvbihhKXt2YXIgbT17
+fQptW2FdPTEKcmV0dXJuIE9iamVjdC5rZXlzKGh1bmtIZWxwZXJzLmNvbnZlcnRUb0Zhc3RPYmplY3Qo
+bSkpWzBdfQp2LmdldElzb2xhdGVUYWc9ZnVuY3Rpb24oYSl7cmV0dXJuIHMoIl9fX2RhcnRfIithK3Yu
+aXNvbGF0ZVRhZyl9CnZhciByPSJfX19kYXJ0X2lzb2xhdGVfdGFnc18iCnZhciBxPU9iamVjdFtyXXx8
+KE9iamVjdFtyXT1PYmplY3QuY3JlYXRlKG51bGwpKQp2YXIgcD0iX1p4WXhYIgpmb3IodmFyIG89MDs7
+bysrKXt2YXIgbj1zKHArIl8iK28rIl8iKQppZighKG4gaW4gcSkpe3Fbbl09MQp2Lmlzb2xhdGVUYWc9
+bgpicmVha319di5kaXNwYXRjaFByb3BlcnR5TmFtZT12LmdldElzb2xhdGVUYWcoImRpc3BhdGNoX3Jl
+Y29yZCIpfSgpCmh1bmtIZWxwZXJzLnNldE9yVXBkYXRlSW50ZXJjZXB0b3JzQnlUYWcoe0RPTUVycm9y
+OkouR3YsTWVkaWFFcnJvcjpKLkd2LE5hdmlnYXRvcjpKLkd2LE5hdmlnYXRvckNvbmN1cnJlbnRIYXJk
+d2FyZTpKLkd2LE5hdmlnYXRvclVzZXJNZWRpYUVycm9yOkouR3YsT3ZlcmNvbnN0cmFpbmVkRXJyb3I6
+Si5HdixQb3NpdGlvbkVycm9yOkouR3YsUmFuZ2U6Si5HdixTUUxFcnJvcjpKLkd2LERhdGFWaWV3Okgu
+RVQsQXJyYXlCdWZmZXJWaWV3OkguRVQsRmxvYXQzMkFycmF5OkguRGcsRmxvYXQ2NEFycmF5OkguRGcs
+SW50MTZBcnJheTpILnhqLEludDMyQXJyYXk6SC5kRSxJbnQ4QXJyYXk6SC5aQSxVaW50MTZBcnJheTpI
+LmRULFVpbnQzMkFycmF5OkguUHEsVWludDhDbGFtcGVkQXJyYXk6SC5lRSxDYW52YXNQaXhlbEFycmF5
+OkguZUUsVWludDhBcnJheTpILlY2LEhUTUxBdWRpb0VsZW1lbnQ6Vy5xRSxIVE1MQlJFbGVtZW50Olcu
+cUUsSFRNTEJ1dHRvbkVsZW1lbnQ6Vy5xRSxIVE1MQ2FudmFzRWxlbWVudDpXLnFFLEhUTUxDb250ZW50
+RWxlbWVudDpXLnFFLEhUTUxETGlzdEVsZW1lbnQ6Vy5xRSxIVE1MRGF0YUVsZW1lbnQ6Vy5xRSxIVE1M
+RGF0YUxpc3RFbGVtZW50OlcucUUsSFRNTERldGFpbHNFbGVtZW50OlcucUUsSFRNTERpYWxvZ0VsZW1l
+bnQ6Vy5xRSxIVE1MRGl2RWxlbWVudDpXLnFFLEhUTUxFbWJlZEVsZW1lbnQ6Vy5xRSxIVE1MRmllbGRT
+ZXRFbGVtZW50OlcucUUsSFRNTEhSRWxlbWVudDpXLnFFLEhUTUxIZWFkRWxlbWVudDpXLnFFLEhUTUxI
+ZWFkaW5nRWxlbWVudDpXLnFFLEhUTUxIdG1sRWxlbWVudDpXLnFFLEhUTUxJRnJhbWVFbGVtZW50Olcu
+cUUsSFRNTEltYWdlRWxlbWVudDpXLnFFLEhUTUxJbnB1dEVsZW1lbnQ6Vy5xRSxIVE1MTElFbGVtZW50
+OlcucUUsSFRNTExhYmVsRWxlbWVudDpXLnFFLEhUTUxMZWdlbmRFbGVtZW50OlcucUUsSFRNTExpbmtF
+bGVtZW50OlcucUUsSFRNTE1hcEVsZW1lbnQ6Vy5xRSxIVE1MTWVkaWFFbGVtZW50OlcucUUsSFRNTE1l
+bnVFbGVtZW50OlcucUUsSFRNTE1ldGFFbGVtZW50OlcucUUsSFRNTE1ldGVyRWxlbWVudDpXLnFFLEhU
+TUxNb2RFbGVtZW50OlcucUUsSFRNTE9MaXN0RWxlbWVudDpXLnFFLEhUTUxPYmplY3RFbGVtZW50Olcu
+cUUsSFRNTE9wdEdyb3VwRWxlbWVudDpXLnFFLEhUTUxPcHRpb25FbGVtZW50OlcucUUsSFRNTE91dHB1
+dEVsZW1lbnQ6Vy5xRSxIVE1MUGFyYW1FbGVtZW50OlcucUUsSFRNTFBpY3R1cmVFbGVtZW50OlcucUUs
+SFRNTFByZUVsZW1lbnQ6Vy5xRSxIVE1MUHJvZ3Jlc3NFbGVtZW50OlcucUUsSFRNTFF1b3RlRWxlbWVu
+dDpXLnFFLEhUTUxTY3JpcHRFbGVtZW50OlcucUUsSFRNTFNoYWRvd0VsZW1lbnQ6Vy5xRSxIVE1MU2xv
+dEVsZW1lbnQ6Vy5xRSxIVE1MU291cmNlRWxlbWVudDpXLnFFLEhUTUxTcGFuRWxlbWVudDpXLnFFLEhU
+TUxTdHlsZUVsZW1lbnQ6Vy5xRSxIVE1MVGFibGVDYXB0aW9uRWxlbWVudDpXLnFFLEhUTUxUYWJsZUNl
+bGxFbGVtZW50OlcucUUsSFRNTFRhYmxlRGF0YUNlbGxFbGVtZW50OlcucUUsSFRNTFRhYmxlSGVhZGVy
+Q2VsbEVsZW1lbnQ6Vy5xRSxIVE1MVGFibGVDb2xFbGVtZW50OlcucUUsSFRNTFRleHRBcmVhRWxlbWVu
+dDpXLnFFLEhUTUxUaW1lRWxlbWVudDpXLnFFLEhUTUxUaXRsZUVsZW1lbnQ6Vy5xRSxIVE1MVHJhY2tF
+bGVtZW50OlcucUUsSFRNTFVMaXN0RWxlbWVudDpXLnFFLEhUTUxVbmtub3duRWxlbWVudDpXLnFFLEhU
+TUxWaWRlb0VsZW1lbnQ6Vy5xRSxIVE1MRGlyZWN0b3J5RWxlbWVudDpXLnFFLEhUTUxGb250RWxlbWVu
+dDpXLnFFLEhUTUxGcmFtZUVsZW1lbnQ6Vy5xRSxIVE1MRnJhbWVTZXRFbGVtZW50OlcucUUsSFRNTE1h
+cnF1ZWVFbGVtZW50OlcucUUsSFRNTEVsZW1lbnQ6Vy5xRSxIVE1MQW5jaG9yRWxlbWVudDpXLkdoLEhU
+TUxBcmVhRWxlbWVudDpXLmZZLEhUTUxCYXNlRWxlbWVudDpXLm5CLEJsb2I6Vy5BeixIVE1MQm9keUVs
+ZW1lbnQ6Vy5RUCxDREFUQVNlY3Rpb246Vy5ueCxDaGFyYWN0ZXJEYXRhOlcubngsQ29tbWVudDpXLm54
+LFByb2Nlc3NpbmdJbnN0cnVjdGlvbjpXLm54LFRleHQ6Vy5ueCxDU1NTdHlsZURlY2xhcmF0aW9uOlcu
+b0osTVNTdHlsZUNTU1Byb3BlcnRpZXM6Vy5vSixDU1MyUHJvcGVydGllczpXLm9KLFhNTERvY3VtZW50
+OlcuUUYsRG9jdW1lbnQ6Vy5RRixET01FeGNlcHRpb246Vy5OaCxET01JbXBsZW1lbnRhdGlvbjpXLmFl
+LERPTVJlY3RSZWFkT25seTpXLklCLERPTVRva2VuTGlzdDpXLm43LEVsZW1lbnQ6Vy5jdixBYm9ydFBh
+eW1lbnRFdmVudDpXLmVhLEFuaW1hdGlvbkV2ZW50OlcuZWEsQW5pbWF0aW9uUGxheWJhY2tFdmVudDpX
+LmVhLEFwcGxpY2F0aW9uQ2FjaGVFcnJvckV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVu
+dDpXLmVhLEJhY2tncm91bmRGZXRjaEV2ZW50OlcuZWEsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50Olcu
+ZWEsQmFja2dyb3VuZEZldGNoZWRFdmVudDpXLmVhLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDpXLmVh
+LEJlZm9yZVVubG9hZEV2ZW50OlcuZWEsQmxvYkV2ZW50OlcuZWEsQ2FuTWFrZVBheW1lbnRFdmVudDpX
+LmVhLENsaXBib2FyZEV2ZW50OlcuZWEsQ2xvc2VFdmVudDpXLmVhLEN1c3RvbUV2ZW50OlcuZWEsRGV2
+aWNlTW90aW9uRXZlbnQ6Vy5lYSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OlcuZWEsRXJyb3JFdmVudDpX
+LmVhLEV4dGVuZGFibGVFdmVudDpXLmVhLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6Vy5lYSxGZXRjaEV2
+ZW50OlcuZWEsRm9udEZhY2VTZXRMb2FkRXZlbnQ6Vy5lYSxGb3JlaWduRmV0Y2hFdmVudDpXLmVhLEdh
+bWVwYWRFdmVudDpXLmVhLEhhc2hDaGFuZ2VFdmVudDpXLmVhLEluc3RhbGxFdmVudDpXLmVhLE1lZGlh
+RW5jcnlwdGVkRXZlbnQ6Vy5lYSxNZWRpYUtleU1lc3NhZ2VFdmVudDpXLmVhLE1lZGlhUXVlcnlMaXN0
+RXZlbnQ6Vy5lYSxNZWRpYVN0cmVhbUV2ZW50OlcuZWEsTWVkaWFTdHJlYW1UcmFja0V2ZW50OlcuZWEs
+TWVzc2FnZUV2ZW50OlcuZWEsTUlESUNvbm5lY3Rpb25FdmVudDpXLmVhLE1JRElNZXNzYWdlRXZlbnQ6
+Vy5lYSxNdXRhdGlvbkV2ZW50OlcuZWEsTm90aWZpY2F0aW9uRXZlbnQ6Vy5lYSxQYWdlVHJhbnNpdGlv
+bkV2ZW50OlcuZWEsUGF5bWVudFJlcXVlc3RFdmVudDpXLmVhLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZl
+bnQ6Vy5lYSxQb3BTdGF0ZUV2ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2
+ZW50OlcuZWEsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6Vy5lYSxQcm9taXNlUmVqZWN0
+aW9uRXZlbnQ6Vy5lYSxQdXNoRXZlbnQ6Vy5lYSxSVENEYXRhQ2hhbm5lbEV2ZW50OlcuZWEsUlRDRFRN
+RlRvbmVDaGFuZ2VFdmVudDpXLmVhLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6Vy5lYSxSVENUcmFj
+a0V2ZW50OlcuZWEsU2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDpXLmVhLFNlbnNvckVycm9yRXZl
+bnQ6Vy5lYSxTcGVlY2hSZWNvZ25pdGlvbkVycm9yOlcuZWEsU3BlZWNoUmVjb2duaXRpb25FdmVudDpX
+LmVhLFNwZWVjaFN5bnRoZXNpc0V2ZW50OlcuZWEsU3RvcmFnZUV2ZW50OlcuZWEsU3luY0V2ZW50Olcu
+ZWEsVHJhY2tFdmVudDpXLmVhLFRyYW5zaXRpb25FdmVudDpXLmVhLFdlYktpdFRyYW5zaXRpb25FdmVu
+dDpXLmVhLFZSRGV2aWNlRXZlbnQ6Vy5lYSxWUkRpc3BsYXlFdmVudDpXLmVhLFZSU2Vzc2lvbkV2ZW50
+OlcuZWEsTW9qb0ludGVyZmFjZVJlcXVlc3RFdmVudDpXLmVhLFVTQkNvbm5lY3Rpb25FdmVudDpXLmVh
+LElEQlZlcnNpb25DaGFuZ2VFdmVudDpXLmVhLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OlcuZWEsT2ZmbGlu
+ZUF1ZGlvQ29tcGxldGlvbkV2ZW50OlcuZWEsV2ViR0xDb250ZXh0RXZlbnQ6Vy5lYSxFdmVudDpXLmVh
+LElucHV0RXZlbnQ6Vy5lYSxTdWJtaXRFdmVudDpXLmVhLEV2ZW50VGFyZ2V0OlcuRDAsRmlsZTpXLmhI
+LEhUTUxGb3JtRWxlbWVudDpXLmg0LEhpc3Rvcnk6Vy5icixIVE1MRG9jdW1lbnQ6Vy5WYixYTUxIdHRw
+UmVxdWVzdDpXLmZKLFhNTEh0dHBSZXF1ZXN0RXZlbnRUYXJnZXQ6Vy53YSxJbWFnZURhdGE6Vy5TZyxM
+b2NhdGlvbjpXLnc3LE1vdXNlRXZlbnQ6Vy5BaixEcmFnRXZlbnQ6Vy5BaixQb2ludGVyRXZlbnQ6Vy5B
+aixXaGVlbEV2ZW50OlcuQWosRG9jdW1lbnRGcmFnbWVudDpXLnVILFNoYWRvd1Jvb3Q6Vy51SCxEb2N1
+bWVudFR5cGU6Vy51SCxOb2RlOlcudUgsTm9kZUxpc3Q6Vy5CSCxSYWRpb05vZGVMaXN0OlcuQkgsSFRN
+TFBhcmFncmFwaEVsZW1lbnQ6Vy5TTixQcm9ncmVzc0V2ZW50OlcuZXcsUmVzb3VyY2VQcm9ncmVzc0V2
+ZW50OlcuZXcsSFRNTFNlbGVjdEVsZW1lbnQ6Vy5scCxIVE1MVGFibGVFbGVtZW50OlcuVGIsSFRNTFRh
+YmxlUm93RWxlbWVudDpXLkl2LEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OlcuV1AsSFRNTFRlbXBsYXRl
+RWxlbWVudDpXLnlZLENvbXBvc2l0aW9uRXZlbnQ6Vy53NixGb2N1c0V2ZW50OlcudzYsS2V5Ym9hcmRF
+dmVudDpXLnc2LFRleHRFdmVudDpXLnc2LFRvdWNoRXZlbnQ6Vy53NixVSUV2ZW50OlcudzYsV2luZG93
+OlcuSzUsRE9NV2luZG93OlcuSzUsRGVkaWNhdGVkV29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxTZXJ2aWNl
+V29ya2VyR2xvYmFsU2NvcGU6Vy5DbSxTaGFyZWRXb3JrZXJHbG9iYWxTY29wZTpXLkNtLFdvcmtlckds
+b2JhbFNjb3BlOlcuQ20sQXR0cjpXLkNRLENsaWVudFJlY3Q6Vy53NCxET01SZWN0OlcudzQsTmFtZWRO
+b2RlTWFwOlcucmgsTW96TmFtZWRBdHRyTWFwOlcucmgsSURCS2V5UmFuZ2U6UC5oRixTVkdTY3JpcHRF
+bGVtZW50OlAubmQsU1ZHQUVsZW1lbnQ6UC5oaSxTVkdBbmltYXRlRWxlbWVudDpQLmhpLFNWR0FuaW1h
+dGVNb3Rpb25FbGVtZW50OlAuaGksU1ZHQW5pbWF0ZVRyYW5zZm9ybUVsZW1lbnQ6UC5oaSxTVkdBbmlt
+YXRpb25FbGVtZW50OlAuaGksU1ZHQ2lyY2xlRWxlbWVudDpQLmhpLFNWR0NsaXBQYXRoRWxlbWVudDpQ
+LmhpLFNWR0RlZnNFbGVtZW50OlAuaGksU1ZHRGVzY0VsZW1lbnQ6UC5oaSxTVkdEaXNjYXJkRWxlbWVu
+dDpQLmhpLFNWR0VsbGlwc2VFbGVtZW50OlAuaGksU1ZHRkVCbGVuZEVsZW1lbnQ6UC5oaSxTVkdGRUNv
+bG9yTWF0cml4RWxlbWVudDpQLmhpLFNWR0ZFQ29tcG9uZW50VHJhbnNmZXJFbGVtZW50OlAuaGksU1ZH
+RkVDb21wb3NpdGVFbGVtZW50OlAuaGksU1ZHRkVDb252b2x2ZU1hdHJpeEVsZW1lbnQ6UC5oaSxTVkdG
+RURpZmZ1c2VMaWdodGluZ0VsZW1lbnQ6UC5oaSxTVkdGRURpc3BsYWNlbWVudE1hcEVsZW1lbnQ6UC5o
+aSxTVkdGRURpc3RhbnRMaWdodEVsZW1lbnQ6UC5oaSxTVkdGRUZsb29kRWxlbWVudDpQLmhpLFNWR0ZF
+RnVuY0FFbGVtZW50OlAuaGksU1ZHRkVGdW5jQkVsZW1lbnQ6UC5oaSxTVkdGRUZ1bmNHRWxlbWVudDpQ
+LmhpLFNWR0ZFRnVuY1JFbGVtZW50OlAuaGksU1ZHRkVHYXVzc2lhbkJsdXJFbGVtZW50OlAuaGksU1ZH
+RkVJbWFnZUVsZW1lbnQ6UC5oaSxTVkdGRU1lcmdlRWxlbWVudDpQLmhpLFNWR0ZFTWVyZ2VOb2RlRWxl
+bWVudDpQLmhpLFNWR0ZFTW9ycGhvbG9neUVsZW1lbnQ6UC5oaSxTVkdGRU9mZnNldEVsZW1lbnQ6UC5o
+aSxTVkdGRVBvaW50TGlnaHRFbGVtZW50OlAuaGksU1ZHRkVTcGVjdWxhckxpZ2h0aW5nRWxlbWVudDpQ
+LmhpLFNWR0ZFU3BvdExpZ2h0RWxlbWVudDpQLmhpLFNWR0ZFVGlsZUVsZW1lbnQ6UC5oaSxTVkdGRVR1
+cmJ1bGVuY2VFbGVtZW50OlAuaGksU1ZHRmlsdGVyRWxlbWVudDpQLmhpLFNWR0ZvcmVpZ25PYmplY3RF
+bGVtZW50OlAuaGksU1ZHR0VsZW1lbnQ6UC5oaSxTVkdHZW9tZXRyeUVsZW1lbnQ6UC5oaSxTVkdHcmFw
+aGljc0VsZW1lbnQ6UC5oaSxTVkdJbWFnZUVsZW1lbnQ6UC5oaSxTVkdMaW5lRWxlbWVudDpQLmhpLFNW
+R0xpbmVhckdyYWRpZW50RWxlbWVudDpQLmhpLFNWR01hcmtlckVsZW1lbnQ6UC5oaSxTVkdNYXNrRWxl
+bWVudDpQLmhpLFNWR01ldGFkYXRhRWxlbWVudDpQLmhpLFNWR1BhdGhFbGVtZW50OlAuaGksU1ZHUGF0
+dGVybkVsZW1lbnQ6UC5oaSxTVkdQb2x5Z29uRWxlbWVudDpQLmhpLFNWR1BvbHlsaW5lRWxlbWVudDpQ
+LmhpLFNWR1JhZGlhbEdyYWRpZW50RWxlbWVudDpQLmhpLFNWR1JlY3RFbGVtZW50OlAuaGksU1ZHU2V0
+RWxlbWVudDpQLmhpLFNWR1N0b3BFbGVtZW50OlAuaGksU1ZHU3R5bGVFbGVtZW50OlAuaGksU1ZHU1ZH
+RWxlbWVudDpQLmhpLFNWR1N3aXRjaEVsZW1lbnQ6UC5oaSxTVkdTeW1ib2xFbGVtZW50OlAuaGksU1ZH
+VFNwYW5FbGVtZW50OlAuaGksU1ZHVGV4dENvbnRlbnRFbGVtZW50OlAuaGksU1ZHVGV4dEVsZW1lbnQ6
+UC5oaSxTVkdUZXh0UGF0aEVsZW1lbnQ6UC5oaSxTVkdUZXh0UG9zaXRpb25pbmdFbGVtZW50OlAuaGks
+U1ZHVGl0bGVFbGVtZW50OlAuaGksU1ZHVXNlRWxlbWVudDpQLmhpLFNWR1ZpZXdFbGVtZW50OlAuaGks
+U1ZHR3JhZGllbnRFbGVtZW50OlAuaGksU1ZHQ29tcG9uZW50VHJhbnNmZXJGdW5jdGlvbkVsZW1lbnQ6
+UC5oaSxTVkdGRURyb3BTaGFkb3dFbGVtZW50OlAuaGksU1ZHTVBhdGhFbGVtZW50OlAuaGksU1ZHRWxl
+bWVudDpQLmhpfSkKaHVua0hlbHBlcnMuc2V0T3JVcGRhdGVMZWFmVGFncyh7RE9NRXJyb3I6dHJ1ZSxN
+ZWRpYUVycm9yOnRydWUsTmF2aWdhdG9yOnRydWUsTmF2aWdhdG9yQ29uY3VycmVudEhhcmR3YXJlOnRy
+dWUsTmF2aWdhdG9yVXNlck1lZGlhRXJyb3I6dHJ1ZSxPdmVyY29uc3RyYWluZWRFcnJvcjp0cnVlLFBv
+c2l0aW9uRXJyb3I6dHJ1ZSxSYW5nZTp0cnVlLFNRTEVycm9yOnRydWUsRGF0YVZpZXc6dHJ1ZSxBcnJh
+eUJ1ZmZlclZpZXc6ZmFsc2UsRmxvYXQzMkFycmF5OnRydWUsRmxvYXQ2NEFycmF5OnRydWUsSW50MTZB
+cnJheTp0cnVlLEludDMyQXJyYXk6dHJ1ZSxJbnQ4QXJyYXk6dHJ1ZSxVaW50MTZBcnJheTp0cnVlLFVp
+bnQzMkFycmF5OnRydWUsVWludDhDbGFtcGVkQXJyYXk6dHJ1ZSxDYW52YXNQaXhlbEFycmF5OnRydWUs
+VWludDhBcnJheTpmYWxzZSxIVE1MQXVkaW9FbGVtZW50OnRydWUsSFRNTEJSRWxlbWVudDp0cnVlLEhU
+TUxCdXR0b25FbGVtZW50OnRydWUsSFRNTENhbnZhc0VsZW1lbnQ6dHJ1ZSxIVE1MQ29udGVudEVsZW1l
+bnQ6dHJ1ZSxIVE1MRExpc3RFbGVtZW50OnRydWUsSFRNTERhdGFFbGVtZW50OnRydWUsSFRNTERhdGFM
+aXN0RWxlbWVudDp0cnVlLEhUTUxEZXRhaWxzRWxlbWVudDp0cnVlLEhUTUxEaWFsb2dFbGVtZW50OnRy
+dWUsSFRNTERpdkVsZW1lbnQ6dHJ1ZSxIVE1MRW1iZWRFbGVtZW50OnRydWUsSFRNTEZpZWxkU2V0RWxl
+bWVudDp0cnVlLEhUTUxIUkVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZEVsZW1lbnQ6dHJ1ZSxIVE1MSGVhZGlu
+Z0VsZW1lbnQ6dHJ1ZSxIVE1MSHRtbEVsZW1lbnQ6dHJ1ZSxIVE1MSUZyYW1lRWxlbWVudDp0cnVlLEhU
+TUxJbWFnZUVsZW1lbnQ6dHJ1ZSxIVE1MSW5wdXRFbGVtZW50OnRydWUsSFRNTExJRWxlbWVudDp0cnVl
+LEhUTUxMYWJlbEVsZW1lbnQ6dHJ1ZSxIVE1MTGVnZW5kRWxlbWVudDp0cnVlLEhUTUxMaW5rRWxlbWVu
+dDp0cnVlLEhUTUxNYXBFbGVtZW50OnRydWUsSFRNTE1lZGlhRWxlbWVudDp0cnVlLEhUTUxNZW51RWxl
+bWVudDp0cnVlLEhUTUxNZXRhRWxlbWVudDp0cnVlLEhUTUxNZXRlckVsZW1lbnQ6dHJ1ZSxIVE1MTW9k
+RWxlbWVudDp0cnVlLEhUTUxPTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MT2JqZWN0RWxlbWVudDp0cnVlLEhU
+TUxPcHRHcm91cEVsZW1lbnQ6dHJ1ZSxIVE1MT3B0aW9uRWxlbWVudDp0cnVlLEhUTUxPdXRwdXRFbGVt
+ZW50OnRydWUsSFRNTFBhcmFtRWxlbWVudDp0cnVlLEhUTUxQaWN0dXJlRWxlbWVudDp0cnVlLEhUTUxQ
+cmVFbGVtZW50OnRydWUsSFRNTFByb2dyZXNzRWxlbWVudDp0cnVlLEhUTUxRdW90ZUVsZW1lbnQ6dHJ1
+ZSxIVE1MU2NyaXB0RWxlbWVudDp0cnVlLEhUTUxTaGFkb3dFbGVtZW50OnRydWUsSFRNTFNsb3RFbGVt
+ZW50OnRydWUsSFRNTFNvdXJjZUVsZW1lbnQ6dHJ1ZSxIVE1MU3BhbkVsZW1lbnQ6dHJ1ZSxIVE1MU3R5
+bGVFbGVtZW50OnRydWUsSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVDZWxsRWxl
+bWVudDp0cnVlLEhUTUxUYWJsZURhdGFDZWxsRWxlbWVudDp0cnVlLEhUTUxUYWJsZUhlYWRlckNlbGxF
+bGVtZW50OnRydWUsSFRNTFRhYmxlQ29sRWxlbWVudDp0cnVlLEhUTUxUZXh0QXJlYUVsZW1lbnQ6dHJ1
+ZSxIVE1MVGltZUVsZW1lbnQ6dHJ1ZSxIVE1MVGl0bGVFbGVtZW50OnRydWUsSFRNTFRyYWNrRWxlbWVu
+dDp0cnVlLEhUTUxVTGlzdEVsZW1lbnQ6dHJ1ZSxIVE1MVW5rbm93bkVsZW1lbnQ6dHJ1ZSxIVE1MVmlk
+ZW9FbGVtZW50OnRydWUsSFRNTERpcmVjdG9yeUVsZW1lbnQ6dHJ1ZSxIVE1MRm9udEVsZW1lbnQ6dHJ1
+ZSxIVE1MRnJhbWVFbGVtZW50OnRydWUsSFRNTEZyYW1lU2V0RWxlbWVudDp0cnVlLEhUTUxNYXJxdWVl
+RWxlbWVudDp0cnVlLEhUTUxFbGVtZW50OmZhbHNlLEhUTUxBbmNob3JFbGVtZW50OnRydWUsSFRNTEFy
+ZWFFbGVtZW50OnRydWUsSFRNTEJhc2VFbGVtZW50OnRydWUsQmxvYjpmYWxzZSxIVE1MQm9keUVsZW1l
+bnQ6dHJ1ZSxDREFUQVNlY3Rpb246dHJ1ZSxDaGFyYWN0ZXJEYXRhOnRydWUsQ29tbWVudDp0cnVlLFBy
+b2Nlc3NpbmdJbnN0cnVjdGlvbjp0cnVlLFRleHQ6dHJ1ZSxDU1NTdHlsZURlY2xhcmF0aW9uOnRydWUs
+TVNTdHlsZUNTU1Byb3BlcnRpZXM6dHJ1ZSxDU1MyUHJvcGVydGllczp0cnVlLFhNTERvY3VtZW50OnRy
+dWUsRG9jdW1lbnQ6ZmFsc2UsRE9NRXhjZXB0aW9uOnRydWUsRE9NSW1wbGVtZW50YXRpb246dHJ1ZSxE
+T01SZWN0UmVhZE9ubHk6ZmFsc2UsRE9NVG9rZW5MaXN0OnRydWUsRWxlbWVudDpmYWxzZSxBYm9ydFBh
+eW1lbnRFdmVudDp0cnVlLEFuaW1hdGlvbkV2ZW50OnRydWUsQW5pbWF0aW9uUGxheWJhY2tFdmVudDp0
+cnVlLEFwcGxpY2F0aW9uQ2FjaGVFcnJvckV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoQ2xpY2tFdmVu
+dDp0cnVlLEJhY2tncm91bmRGZXRjaEV2ZW50OnRydWUsQmFja2dyb3VuZEZldGNoRmFpbEV2ZW50OnRy
+dWUsQmFja2dyb3VuZEZldGNoZWRFdmVudDp0cnVlLEJlZm9yZUluc3RhbGxQcm9tcHRFdmVudDp0cnVl
+LEJlZm9yZVVubG9hZEV2ZW50OnRydWUsQmxvYkV2ZW50OnRydWUsQ2FuTWFrZVBheW1lbnRFdmVudDp0
+cnVlLENsaXBib2FyZEV2ZW50OnRydWUsQ2xvc2VFdmVudDp0cnVlLEN1c3RvbUV2ZW50OnRydWUsRGV2
+aWNlTW90aW9uRXZlbnQ6dHJ1ZSxEZXZpY2VPcmllbnRhdGlvbkV2ZW50OnRydWUsRXJyb3JFdmVudDp0
+cnVlLEV4dGVuZGFibGVFdmVudDp0cnVlLEV4dGVuZGFibGVNZXNzYWdlRXZlbnQ6dHJ1ZSxGZXRjaEV2
+ZW50OnRydWUsRm9udEZhY2VTZXRMb2FkRXZlbnQ6dHJ1ZSxGb3JlaWduRmV0Y2hFdmVudDp0cnVlLEdh
+bWVwYWRFdmVudDp0cnVlLEhhc2hDaGFuZ2VFdmVudDp0cnVlLEluc3RhbGxFdmVudDp0cnVlLE1lZGlh
+RW5jcnlwdGVkRXZlbnQ6dHJ1ZSxNZWRpYUtleU1lc3NhZ2VFdmVudDp0cnVlLE1lZGlhUXVlcnlMaXN0
+RXZlbnQ6dHJ1ZSxNZWRpYVN0cmVhbUV2ZW50OnRydWUsTWVkaWFTdHJlYW1UcmFja0V2ZW50OnRydWUs
+TWVzc2FnZUV2ZW50OnRydWUsTUlESUNvbm5lY3Rpb25FdmVudDp0cnVlLE1JRElNZXNzYWdlRXZlbnQ6
+dHJ1ZSxNdXRhdGlvbkV2ZW50OnRydWUsTm90aWZpY2F0aW9uRXZlbnQ6dHJ1ZSxQYWdlVHJhbnNpdGlv
+bkV2ZW50OnRydWUsUGF5bWVudFJlcXVlc3RFdmVudDp0cnVlLFBheW1lbnRSZXF1ZXN0VXBkYXRlRXZl
+bnQ6dHJ1ZSxQb3BTdGF0ZUV2ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkF2YWlsYWJsZUV2
+ZW50OnRydWUsUHJlc2VudGF0aW9uQ29ubmVjdGlvbkNsb3NlRXZlbnQ6dHJ1ZSxQcm9taXNlUmVqZWN0
+aW9uRXZlbnQ6dHJ1ZSxQdXNoRXZlbnQ6dHJ1ZSxSVENEYXRhQ2hhbm5lbEV2ZW50OnRydWUsUlRDRFRN
+RlRvbmVDaGFuZ2VFdmVudDp0cnVlLFJUQ1BlZXJDb25uZWN0aW9uSWNlRXZlbnQ6dHJ1ZSxSVENUcmFj
+a0V2ZW50OnRydWUsU2VjdXJpdHlQb2xpY3lWaW9sYXRpb25FdmVudDp0cnVlLFNlbnNvckVycm9yRXZl
+bnQ6dHJ1ZSxTcGVlY2hSZWNvZ25pdGlvbkVycm9yOnRydWUsU3BlZWNoUmVjb2duaXRpb25FdmVudDp0
+cnVlLFNwZWVjaFN5bnRoZXNpc0V2ZW50OnRydWUsU3RvcmFnZUV2ZW50OnRydWUsU3luY0V2ZW50OnRy
+dWUsVHJhY2tFdmVudDp0cnVlLFRyYW5zaXRpb25FdmVudDp0cnVlLFdlYktpdFRyYW5zaXRpb25FdmVu
+dDp0cnVlLFZSRGV2aWNlRXZlbnQ6dHJ1ZSxWUkRpc3BsYXlFdmVudDp0cnVlLFZSU2Vzc2lvbkV2ZW50
+OnRydWUsTW9qb0ludGVyZmFjZVJlcXVlc3RFdmVudDp0cnVlLFVTQkNvbm5lY3Rpb25FdmVudDp0cnVl
+LElEQlZlcnNpb25DaGFuZ2VFdmVudDp0cnVlLEF1ZGlvUHJvY2Vzc2luZ0V2ZW50OnRydWUsT2ZmbGlu
+ZUF1ZGlvQ29tcGxldGlvbkV2ZW50OnRydWUsV2ViR0xDb250ZXh0RXZlbnQ6dHJ1ZSxFdmVudDpmYWxz
+ZSxJbnB1dEV2ZW50OmZhbHNlLFN1Ym1pdEV2ZW50OmZhbHNlLEV2ZW50VGFyZ2V0OmZhbHNlLEZpbGU6
+dHJ1ZSxIVE1MRm9ybUVsZW1lbnQ6dHJ1ZSxIaXN0b3J5OnRydWUsSFRNTERvY3VtZW50OnRydWUsWE1M
+SHR0cFJlcXVlc3Q6dHJ1ZSxYTUxIdHRwUmVxdWVzdEV2ZW50VGFyZ2V0OmZhbHNlLEltYWdlRGF0YTp0
+cnVlLExvY2F0aW9uOnRydWUsTW91c2VFdmVudDp0cnVlLERyYWdFdmVudDp0cnVlLFBvaW50ZXJFdmVu
+dDp0cnVlLFdoZWVsRXZlbnQ6dHJ1ZSxEb2N1bWVudEZyYWdtZW50OnRydWUsU2hhZG93Um9vdDp0cnVl
+LERvY3VtZW50VHlwZTp0cnVlLE5vZGU6ZmFsc2UsTm9kZUxpc3Q6dHJ1ZSxSYWRpb05vZGVMaXN0OnRy
+dWUsSFRNTFBhcmFncmFwaEVsZW1lbnQ6dHJ1ZSxQcm9ncmVzc0V2ZW50OnRydWUsUmVzb3VyY2VQcm9n
+cmVzc0V2ZW50OnRydWUsSFRNTFNlbGVjdEVsZW1lbnQ6dHJ1ZSxIVE1MVGFibGVFbGVtZW50OnRydWUs
+SFRNTFRhYmxlUm93RWxlbWVudDp0cnVlLEhUTUxUYWJsZVNlY3Rpb25FbGVtZW50OnRydWUsSFRNTFRl
+bXBsYXRlRWxlbWVudDp0cnVlLENvbXBvc2l0aW9uRXZlbnQ6dHJ1ZSxGb2N1c0V2ZW50OnRydWUsS2V5
+Ym9hcmRFdmVudDp0cnVlLFRleHRFdmVudDp0cnVlLFRvdWNoRXZlbnQ6dHJ1ZSxVSUV2ZW50OmZhbHNl
+LFdpbmRvdzp0cnVlLERPTVdpbmRvdzp0cnVlLERlZGljYXRlZFdvcmtlckdsb2JhbFNjb3BlOnRydWUs
+U2VydmljZVdvcmtlckdsb2JhbFNjb3BlOnRydWUsU2hhcmVkV29ya2VyR2xvYmFsU2NvcGU6dHJ1ZSxX
+b3JrZXJHbG9iYWxTY29wZTp0cnVlLEF0dHI6dHJ1ZSxDbGllbnRSZWN0OnRydWUsRE9NUmVjdDp0cnVl
+LE5hbWVkTm9kZU1hcDp0cnVlLE1vek5hbWVkQXR0ck1hcDp0cnVlLElEQktleVJhbmdlOnRydWUsU1ZH
+U2NyaXB0RWxlbWVudDp0cnVlLFNWR0FFbGVtZW50OnRydWUsU1ZHQW5pbWF0ZUVsZW1lbnQ6dHJ1ZSxT
+VkdBbmltYXRlTW90aW9uRWxlbWVudDp0cnVlLFNWR0FuaW1hdGVUcmFuc2Zvcm1FbGVtZW50OnRydWUs
+U1ZHQW5pbWF0aW9uRWxlbWVudDp0cnVlLFNWR0NpcmNsZUVsZW1lbnQ6dHJ1ZSxTVkdDbGlwUGF0aEVs
+ZW1lbnQ6dHJ1ZSxTVkdEZWZzRWxlbWVudDp0cnVlLFNWR0Rlc2NFbGVtZW50OnRydWUsU1ZHRGlzY2Fy
+ZEVsZW1lbnQ6dHJ1ZSxTVkdFbGxpcHNlRWxlbWVudDp0cnVlLFNWR0ZFQmxlbmRFbGVtZW50OnRydWUs
+U1ZHRkVDb2xvck1hdHJpeEVsZW1lbnQ6dHJ1ZSxTVkdGRUNvbXBvbmVudFRyYW5zZmVyRWxlbWVudDp0
+cnVlLFNWR0ZFQ29tcG9zaXRlRWxlbWVudDp0cnVlLFNWR0ZFQ29udm9sdmVNYXRyaXhFbGVtZW50OnRy
+dWUsU1ZHRkVEaWZmdXNlTGlnaHRpbmdFbGVtZW50OnRydWUsU1ZHRkVEaXNwbGFjZW1lbnRNYXBFbGVt
+ZW50OnRydWUsU1ZHRkVEaXN0YW50TGlnaHRFbGVtZW50OnRydWUsU1ZHRkVGbG9vZEVsZW1lbnQ6dHJ1
+ZSxTVkdGRUZ1bmNBRWxlbWVudDp0cnVlLFNWR0ZFRnVuY0JFbGVtZW50OnRydWUsU1ZHRkVGdW5jR0Vs
+ZW1lbnQ6dHJ1ZSxTVkdGRUZ1bmNSRWxlbWVudDp0cnVlLFNWR0ZFR2F1c3NpYW5CbHVyRWxlbWVudDp0
+cnVlLFNWR0ZFSW1hZ2VFbGVtZW50OnRydWUsU1ZHRkVNZXJnZUVsZW1lbnQ6dHJ1ZSxTVkdGRU1lcmdl
+Tm9kZUVsZW1lbnQ6dHJ1ZSxTVkdGRU1vcnBob2xvZ3lFbGVtZW50OnRydWUsU1ZHRkVPZmZzZXRFbGVt
+ZW50OnRydWUsU1ZHRkVQb2ludExpZ2h0RWxlbWVudDp0cnVlLFNWR0ZFU3BlY3VsYXJMaWdodGluZ0Vs
+ZW1lbnQ6dHJ1ZSxTVkdGRVNwb3RMaWdodEVsZW1lbnQ6dHJ1ZSxTVkdGRVRpbGVFbGVtZW50OnRydWUs
+U1ZHRkVUdXJidWxlbmNlRWxlbWVudDp0cnVlLFNWR0ZpbHRlckVsZW1lbnQ6dHJ1ZSxTVkdGb3JlaWdu
+T2JqZWN0RWxlbWVudDp0cnVlLFNWR0dFbGVtZW50OnRydWUsU1ZHR2VvbWV0cnlFbGVtZW50OnRydWUs
+U1ZHR3JhcGhpY3NFbGVtZW50OnRydWUsU1ZHSW1hZ2VFbGVtZW50OnRydWUsU1ZHTGluZUVsZW1lbnQ6
+dHJ1ZSxTVkdMaW5lYXJHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdNYXJrZXJFbGVtZW50OnRydWUsU1ZH
+TWFza0VsZW1lbnQ6dHJ1ZSxTVkdNZXRhZGF0YUVsZW1lbnQ6dHJ1ZSxTVkdQYXRoRWxlbWVudDp0cnVl
+LFNWR1BhdHRlcm5FbGVtZW50OnRydWUsU1ZHUG9seWdvbkVsZW1lbnQ6dHJ1ZSxTVkdQb2x5bGluZUVs
+ZW1lbnQ6dHJ1ZSxTVkdSYWRpYWxHcmFkaWVudEVsZW1lbnQ6dHJ1ZSxTVkdSZWN0RWxlbWVudDp0cnVl
+LFNWR1NldEVsZW1lbnQ6dHJ1ZSxTVkdTdG9wRWxlbWVudDp0cnVlLFNWR1N0eWxlRWxlbWVudDp0cnVl
+LFNWR1NWR0VsZW1lbnQ6dHJ1ZSxTVkdTd2l0Y2hFbGVtZW50OnRydWUsU1ZHU3ltYm9sRWxlbWVudDp0
+cnVlLFNWR1RTcGFuRWxlbWVudDp0cnVlLFNWR1RleHRDb250ZW50RWxlbWVudDp0cnVlLFNWR1RleHRF
+bGVtZW50OnRydWUsU1ZHVGV4dFBhdGhFbGVtZW50OnRydWUsU1ZHVGV4dFBvc2l0aW9uaW5nRWxlbWVu
+dDp0cnVlLFNWR1RpdGxlRWxlbWVudDp0cnVlLFNWR1VzZUVsZW1lbnQ6dHJ1ZSxTVkdWaWV3RWxlbWVu
+dDp0cnVlLFNWR0dyYWRpZW50RWxlbWVudDp0cnVlLFNWR0NvbXBvbmVudFRyYW5zZmVyRnVuY3Rpb25F
+bGVtZW50OnRydWUsU1ZHRkVEcm9wU2hhZG93RWxlbWVudDp0cnVlLFNWR01QYXRoRWxlbWVudDp0cnVl
+LFNWR0VsZW1lbnQ6ZmFsc2V9KQpILkxaLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZp
+ZXciCkguUkcuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIKSC5WUC4kbmF0aXZl
+U3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILkRnLiRuYXRpdmVTdXBlcmNsYXNzVGFnPSJB
+cnJheUJ1ZmZlclZpZXciCkguV0IuJG5hdGl2ZVN1cGVyY2xhc3NUYWc9IkFycmF5QnVmZmVyVmlldyIK
+SC5aRy4kbmF0aXZlU3VwZXJjbGFzc1RhZz0iQXJyYXlCdWZmZXJWaWV3IgpILlBnLiRuYXRpdmVTdXBl
+cmNsYXNzVGFnPSJBcnJheUJ1ZmZlclZpZXcifSkoKQpjb252ZXJ0QWxsVG9GYXN0T2JqZWN0KHcpCmNv
+bnZlcnRUb0Zhc3RPYmplY3QoJCk7KGZ1bmN0aW9uKGEpe2lmKHR5cGVvZiBkb2N1bWVudD09PSJ1bmRl
+ZmluZWQiKXthKG51bGwpCnJldHVybn1pZih0eXBlb2YgZG9jdW1lbnQuY3VycmVudFNjcmlwdCE9J3Vu
+ZGVmaW5lZCcpe2EoZG9jdW1lbnQuY3VycmVudFNjcmlwdCkKcmV0dXJufXZhciBzPWRvY3VtZW50LnNj
+cmlwdHMKZnVuY3Rpb24gb25Mb2FkKGIpe2Zvcih2YXIgcT0wO3E8cy5sZW5ndGg7KytxKXNbcV0ucmVt
+b3ZlRXZlbnRMaXN0ZW5lcigibG9hZCIsb25Mb2FkLGZhbHNlKQphKGIudGFyZ2V0KX1mb3IodmFyIHI9
+MDtyPHMubGVuZ3RoOysrcilzW3JdLmFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLG9uTG9hZCxmYWxzZSl9
+KShmdW5jdGlvbihhKXt2LmN1cnJlbnRTY3JpcHQ9YQp2YXIgcz1MLklxCmlmKHR5cGVvZiBkYXJ0TWFp
+blJ1bm5lcj09PSJmdW5jdGlvbiIpZGFydE1haW5SdW5uZXIocyxbXSkKZWxzZSBzKFtdKX0pfSkoKQov
+LyMgc291cmNlTWFwcGluZ1VSTD1taWdyYXRpb24uanMubWFwCg==
 ''';
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 2cd6a3d..146ab38 100644
--- a/pkg/nnbd_migration/lib/src/front_end/web/migration.dart
+++ b/pkg/nnbd_migration/lib/src/front_end/web/migration.dart
@@ -464,7 +464,7 @@
   }
 }
 
-void logError(e, st) {
+void logError(Object e, Object st) {
   window.console.error('$e');
   window.console.error('$st');
 }
diff --git a/pkg/nnbd_migration/lib/src/node_builder.dart b/pkg/nnbd_migration/lib/src/node_builder.dart
index 25a697c..77c9de8 100644
--- a/pkg/nnbd_migration/lib/src/node_builder.dart
+++ b/pkg/nnbd_migration/lib/src/node_builder.dart
@@ -366,7 +366,9 @@
   DecoratedType visitFunctionTypeAlias(FunctionTypeAlias node) {
     node.metadata.accept(this);
     var declaredElement = node.declaredElement;
-    var functionType = declaredElement.function.type;
+    var functionElement =
+        declaredElement.aliasedElement as GenericFunctionTypeElement;
+    var functionType = functionElement.type;
     var returnType = node.returnType;
     DecoratedType decoratedReturnType;
     var target = NullabilityNodeTarget.element(declaredElement, _getLineInfo);
@@ -400,7 +402,7 @@
       _namedParameters = previousNamedParameters;
     }
     _variables.recordDecoratedElementType(
-        declaredElement.function, decoratedFunctionType);
+        functionElement, decoratedFunctionType);
     return null;
   }
 
@@ -422,7 +424,7 @@
       decoratedFunctionType = node.functionType.accept(this);
     });
     _variables.recordDecoratedElementType(
-        (node.declaredElement as FunctionTypeAliasElement).function,
+        (node.declaredElement as TypeAliasElement).aliasedElement,
         decoratedFunctionType);
     return null;
   }
@@ -469,7 +471,7 @@
   }
 
   @override
-  visitMixinDeclaration(MixinDeclaration node) {
+  DecoratedType visitMixinDeclaration(MixinDeclaration node) {
     node.metadata.accept(this);
     node.name?.accept(this);
     node.typeParameters?.accept(this);
diff --git a/pkg/nnbd_migration/lib/src/variables.dart b/pkg/nnbd_migration/lib/src/variables.dart
index a3ddc70..84e0ea0 100644
--- a/pkg/nnbd_migration/lib/src/variables.dart
+++ b/pkg/nnbd_migration/lib/src/variables.dart
@@ -390,12 +390,12 @@
       element = element.declaration;
     }
 
-    if (element is FunctionTypeAliasElement) {
+    if (element is TypeAliasElement) {
       // For `typedef F<T> = Function(T)`, get the `function` which is (in this
       // case) `Function(T)`. Without this we would get `Function<T>(T)` which
       // is incorrect. This is a known issue with `.type` on typedefs in the
       // analyzer.
-      element = (element as FunctionTypeAliasElement).function;
+      element = (element as FunctionTypeAliasElement).aliasedElement;
     }
 
     var target = NullabilityNodeTarget.element(element, _getLineInfo);
diff --git a/pkg/nnbd_migration/test/node_builder_test.dart b/pkg/nnbd_migration/test/node_builder_test.dart
index f729846..346e69d 100644
--- a/pkg/nnbd_migration/test/node_builder_test.dart
+++ b/pkg/nnbd_migration/test/node_builder_test.dart
@@ -1054,7 +1054,7 @@
 typedef T F<T, U>(U u);
 ''');
     var element = findElement.functionTypeAlias('F');
-    var decoratedType = variables.decoratedElementType(element.function);
+    var decoratedType = variables.decoratedElementType(element.aliasedElement);
     var t = element.typeParameters[0];
     var u = element.typeParameters[1];
     // typeFormals should be empty because this is not a generic function type,
@@ -1078,8 +1078,8 @@
     await analyze('''
 typedef F();
 ''');
-    var decoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var decoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     expect(decoratedType.returnType.type.isDynamic, isTrue);
     expect(decoratedType.returnType.node.isImmutable, false);
     expect(decoratedType.typeFormals, isEmpty);
@@ -1089,8 +1089,8 @@
     await analyze('''
 typedef int F(String s);
 ''');
-    var decoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var decoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     expect(decoratedType.returnType, same(decoratedTypeAnnotation('int')));
     expect(decoratedType.typeFormals, isEmpty);
     expect(decoratedType.positionalParameters[0],
@@ -1288,7 +1288,7 @@
 typedef F = T Function<T, U>(U u);
 ''');
     var element = findElement.functionTypeAlias('F');
-    var decoratedType = variables.decoratedElementType(element.function);
+    var decoratedType = variables.decoratedElementType(element.aliasedElement);
     expect(decoratedType,
         same(decoratedGenericFunctionTypeAnnotation('T Function')));
     expect(decoratedType.typeFormals, hasLength(2));
@@ -1312,7 +1312,7 @@
 typedef F<T, U> = T Function(U u);
 ''');
     var element = findElement.functionTypeAlias('F');
-    var decoratedType = variables.decoratedElementType(element.function);
+    var decoratedType = variables.decoratedElementType(element.aliasedElement);
     expect(decoratedType,
         same(decoratedGenericFunctionTypeAnnotation('T Function')));
     var t = element.typeParameters[0];
@@ -1338,8 +1338,8 @@
     await analyze('''
 typedef F = Function();
 ''');
-    var decoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var decoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     expect(decoratedType,
         same(decoratedGenericFunctionTypeAnnotation('Function')));
     expect(decoratedType.returnType.type.isDynamic, isTrue);
@@ -1351,8 +1351,8 @@
     await analyze('''
 typedef F = int Function(String s);
 ''');
-    var decoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var decoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     expect(decoratedType,
         same(decoratedGenericFunctionTypeAnnotation('int Function')));
     expect(decoratedType.returnType, same(decoratedTypeAnnotation('int')));
@@ -2070,8 +2070,8 @@
     // from the ones in the typedef (they will be unified by the edge builder).
     // This is necessary because there is no guarantee of whether the typedef or
     // its usage will be visited first.
-    var typedefDecoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var typedefDecoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     var decoratedType = decoratedTypeAnnotation('F<int>');
     expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
     expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
@@ -2091,8 +2091,8 @@
     // from the ones in the typedef (they will be unified by the edge builder).
     // This is necessary because there is no guarantee of whether the typedef or
     // its usage will be visited first.
-    var typedefDecoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var typedefDecoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     var decoratedType = decoratedTypeAnnotation('F f');
     expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
     expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
@@ -2121,8 +2121,8 @@
     // from the ones in the typedef (they will be unified by the edge builder).
     // This is necessary because there is no guarantee of whether the typedef or
     // its usage will be visited first.
-    var typedefDecoratedType = variables
-        .decoratedElementType(findElement.functionTypeAlias('F').function);
+    var typedefDecoratedType = variables.decoratedElementType(
+        findElement.functionTypeAlias('F').aliasedElement);
     var decoratedType = decoratedTypeAnnotation('F f');
     expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
     expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
diff --git a/pkg/nnbd_migration/tool/postmortem.dart b/pkg/nnbd_migration/tool/postmortem.dart
index 2e7a38f..0584991 100644
--- a/pkg/nnbd_migration/tool/postmortem.dart
+++ b/pkg/nnbd_migration/tool/postmortem.dart
@@ -11,7 +11,7 @@
 import 'package:nnbd_migration/src/postmortem_file.dart';
 import 'package:nnbd_migration/src/variables.dart';
 
-main(List<String> args) {
+void main(List<String> args) {
   ArgParser argParser = ArgParser();
   ArgResults parsedArgs;
 
diff --git a/pkg/nnbd_migration/tool/trial_migration.dart b/pkg/nnbd_migration/tool/trial_migration.dart
index 616a5c2..2d0769d 100644
--- a/pkg/nnbd_migration/tool/trial_migration.dart
+++ b/pkg/nnbd_migration/tool/trial_migration.dart
@@ -21,7 +21,7 @@
 
 import 'src/package.dart';
 
-main(List<String> args) async {
+void main(List<String> args) async {
   ArgResults parsedArgs = parseArguments(args);
 
   Sdk sdk = Sdk(parsedArgs['sdk'] as String);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index ed579f2..f2f9877 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -19454,9 +19454,13 @@
     // we have the instructions.
     ASSERT(type_class_id() == kDynamicCid || type_class_id() == kVoidCid);
     StoreNonPointer(&raw_ptr()->type_test_stub_entry_point_, 0);
-  } else {
-    StoreNonPointer(&raw_ptr()->type_test_stub_entry_point_, stub.EntryPoint());
+    raw_ptr()->set_type_test_stub(stub.raw());
+    return;
   }
+
+  Thread* thread = Thread::Current();
+  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
+  StoreNonPointer(&raw_ptr()->type_test_stub_entry_point_, stub.EntryPoint());
   raw_ptr()->set_type_test_stub(stub.raw());
 }
 
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 802d6de..aab8456 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -4336,9 +4336,7 @@
 
   FunctionPtr EnsureInitializerFunction() const;
   FunctionPtr InitializerFunction() const {
-    // We rely on the fact that any loads from the initializer function
-    // are dependent loads and avoid the load-acquire barrier here.
-    return raw_ptr()->initializer_function<std::memory_order_relaxed>();
+    return raw_ptr()->initializer_function<std::memory_order_acquire>();
   }
   void SetInitializerFunction(const Function& initializer) const;
   bool HasInitializerFunction() const;
diff --git a/tools/VERSION b/tools/VERSION
index 4576f76..96fa2f7 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 150
+PRERELEASE 151
 PRERELEASE_PATCH 0
\ No newline at end of file