reverse-name/out.js

// Generated by dart2js (NullSafetyMode.sound, csp, intern-composite-values), the Dart to JavaScript compiler version: 3.3.0.
// The code supports the following hooks:
// dartPrint(message):
//    if this function is defined it is called instead of the Dart [print]
//    method.
//
// dartMainRunner(main, args):
//    if this function is defined, the Dart [main] method will not be invoked
//    directly. Instead, a closure that will invoke [main], and its arguments
//    [args] is passed to [dartMainRunner].
//
// dartDeferredLibraryLoader(uri, successCallback, errorCallback, loadId, loadPriority):
//    if this function is defined, it will be called when a deferred library
//    is loaded. It should load and eval the javascript of `uri`, and call
//    successCallback. If it fails to do so, it should call errorCallback with
//    an error. The loadId argument is the deferred import that resulted in
//    this uri being loaded. The loadPriority argument is the priority the
//    library should be loaded with as specified in the code via the
//    load-priority annotation (0: normal, 1: high).
// dartDeferredLibraryMultiLoader(uris, successCallback, errorCallback, loadId, loadPriority):
//    if this function is defined, it will be called when a deferred library
//    is loaded. It should load and eval the javascript of every URI in `uris`,
//    and call successCallback. If it fails to do so, it should call
//    errorCallback with an error. The loadId argument is the deferred import
//    that resulted in this uri being loaded. The loadPriority argument is the
//    priority the library should be loaded with as specified in the code via
//    the load-priority annotation (0: normal, 1: high).
//
// dartCallInstrumentation(id, qualifiedName):
//    if this function is defined, it will be called at each entry of a
//    method or constructor. Used only when compiling programs with
//    --experiment-call-instrumentation.
(function dartProgram() {
  function copyProperties(from, to) {
    var keys = Object.keys(from);
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      to[key] = from[key];
    }
  }
  function mixinPropertiesHard(from, to) {
    var keys = Object.keys(from);
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      if (!to.hasOwnProperty(key)) {
        to[key] = from[key];
      }
    }
  }
  function mixinPropertiesEasy(from, to) {
    Object.assign(to, from);
  }
  var supportsDirectProtoAccess = function () {
    var cls = function () {
    };
    cls.prototype = { p: {} };
    var object = new cls();
    if (!(Object.getPrototypeOf(object) && Object.getPrototypeOf(object).p === cls.prototype.p))
      return false;
    try {
      if (typeof navigator != "undefined" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Chrome/") >= 0)
        return true;
      if (typeof version == "function" && version.length == 0) {
        var v = version();
        if (/^\d+\.\d+\.\d+\.\d+$/.test(v))
          return true;
      }
    } catch (_) {
    }
    return false;
  }();
  function inherit(cls, sup) {
    cls.prototype.constructor = cls;
    cls.prototype["$is" + cls.name] = cls;
    if (sup != null) {
      if (supportsDirectProtoAccess) {
        Object.setPrototypeOf(cls.prototype, sup.prototype);
        return;
      }
      var clsPrototype = Object.create(sup.prototype);
      copyProperties(cls.prototype, clsPrototype);
      cls.prototype = clsPrototype;
    }
  }
  function inheritMany(sup, classes) {
    for (var i = 0; i < classes.length; i++) {
      inherit(classes[i], sup);
    }
  }
  function mixinEasy(cls, mixin) {
    mixinPropertiesEasy(mixin.prototype, cls.prototype);
    cls.prototype.constructor = cls;
  }
  function mixinHard(cls, mixin) {
    mixinPropertiesHard(mixin.prototype, cls.prototype);
    cls.prototype.constructor = cls;
  }
  function lazyOld(holder, name, getterName, initializer) {
    var uninitializedSentinel = holder;
    holder[name] = uninitializedSentinel;
    holder[getterName] = function () {
      holder[getterName] = function () {
        A.throwCyclicInit(name);
      };
      var result;
      var sentinelInProgress = initializer;
      try {
        if (holder[name] === uninitializedSentinel) {
          result = holder[name] = sentinelInProgress;
          result = holder[name] = initializer();
        } else {
          result = holder[name];
        }
      } finally {
        if (result === sentinelInProgress) {
          holder[name] = null;
        }
        holder[getterName] = function () {
          return this[name];
        };
      }
      return result;
    };
  }
  function lazy(holder, name, getterName, initializer) {
    var uninitializedSentinel = holder;
    holder[name] = uninitializedSentinel;
    holder[getterName] = function () {
      if (holder[name] === uninitializedSentinel) {
        holder[name] = initializer();
      }
      holder[getterName] = function () {
        return this[name];
      };
      return holder[name];
    };
  }
  function lazyFinal(holder, name, getterName, initializer) {
    var uninitializedSentinel = holder;
    holder[name] = uninitializedSentinel;
    holder[getterName] = function () {
      if (holder[name] === uninitializedSentinel) {
        var value = initializer();
        if (holder[name] !== uninitializedSentinel) {
          A.throwLateFieldADI(name);
        }
        holder[name] = value;
      }
      var finalValue = holder[name];
      holder[getterName] = function () {
        return finalValue;
      };
      return finalValue;
    };
  }
  function makeConstList(list) {
    list.immutable$list = Array;
    list.fixed$length = Array;
    return list;
  }
  function convertToFastObject(properties) {
    function t() {
    }
    t.prototype = properties;
    new t();
    return properties;
  }
  function convertAllToFastObject(arrayOfObjects) {
    for (var i = 0; i < arrayOfObjects.length; ++i) {
      convertToFastObject(arrayOfObjects[i]);
    }
  }
  var functionCounter = 0;
  function instanceTearOffGetter(isIntercepted, parameters) {
    var cache = null;
    return isIntercepted ? function (receiver) {
      if (cache === null)
        cache = A.closureFromTearOff(parameters);
      return new cache(receiver, this);
    } : function () {
      if (cache === null)
        cache = A.closureFromTearOff(parameters);
      return new cache(this, null);
    };
  }
  function staticTearOffGetter(parameters) {
    var cache = null;
    return function () {
      if (cache === null)
        cache = A.closureFromTearOff(parameters).prototype;
      return cache;
    };
  }
  var typesOffset = 0;
  function tearOffParameters(container, isStatic, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
    if (typeof funType == "number") {
      funType += typesOffset;
    }
    return { co: container, iS: isStatic, iI: isIntercepted, rC: requiredParameterCount, dV: optionalParameterDefaultValues, cs: callNames, fs: funsOrNames, fT: funType, aI: applyIndex || 0, nDA: needsDirectAccess };
  }
  function installStaticTearOff(holder, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex) {
    var parameters = tearOffParameters(holder, true, false, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, false);
    var getterFunction = staticTearOffGetter(parameters);
    holder[getterName] = getterFunction;
  }
  function installInstanceTearOff(prototype, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, needsDirectAccess) {
    isIntercepted = !!isIntercepted;
    var parameters = tearOffParameters(prototype, false, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, funsOrNames, funType, applyIndex, !!needsDirectAccess);
    var getterFunction = instanceTearOffGetter(isIntercepted, parameters);
    prototype[getterName] = getterFunction;
  }
  function setOrUpdateInterceptorsByTag(newTags) {
    var tags = init.interceptorsByTag;
    if (!tags) {
      init.interceptorsByTag = newTags;
      return;
    }
    copyProperties(newTags, tags);
  }
  function setOrUpdateLeafTags(newTags) {
    var tags = init.leafTags;
    if (!tags) {
      init.leafTags = newTags;
      return;
    }
    copyProperties(newTags, tags);
  }
  function updateTypes(newTypes) {
    var types = init.types;
    var length = types.length;
    types.push.apply(types, newTypes);
    return length;
  }
  function updateHolder(holder, newHolder) {
    copyProperties(newHolder, holder);
    return holder;
  }
  var hunkHelpers = function () {
    var mkInstance = function (isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
      return function (container, getterName, name, funType) {
        return installInstanceTearOff(container, getterName, isIntercepted, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex, false);
      };
    },
      mkStatic = function (requiredParameterCount, optionalParameterDefaultValues, callNames, applyIndex) {
        return function (container, getterName, name, funType) {
          return installStaticTearOff(container, getterName, requiredParameterCount, optionalParameterDefaultValues, callNames, [name], funType, applyIndex);
        };
      };
    return { inherit: inherit, inheritMany: inheritMany, mixin: mixinEasy, mixinHard: mixinHard, installStaticTearOff: installStaticTearOff, installInstanceTearOff: installInstanceTearOff, _instance_0u: mkInstance(0, 0, null, ["call$0"], 0), _instance_1u: mkInstance(0, 1, null, ["call$1"], 0), _instance_2u: mkInstance(0, 2, null, ["call$2"], 0), _instance_0i: mkInstance(1, 0, null, ["call$0"], 0), _instance_1i: mkInstance(1, 1, null, ["call$1"], 0), _instance_2i: mkInstance(1, 2, null, ["call$2"], 0), _static_0: mkStatic(0, null, ["call$0"], 0), _static_1: mkStatic(1, null, ["call$1"], 0), _static_2: mkStatic(2, null, ["call$2"], 0), makeConstList: makeConstList, lazy: lazy, lazyFinal: lazyFinal, lazyOld: lazyOld, updateHolder: updateHolder, convertToFastObject: convertToFastObject, updateTypes: updateTypes, setOrUpdateInterceptorsByTag: setOrUpdateInterceptorsByTag, setOrUpdateLeafTags: setOrUpdateLeafTags };
  }();
  function initializeDeferredHunk(hunk) {
    typesOffset = init.types.length;
    hunk(hunkHelpers, init, holders, $);
  }
  var J = {
    getInterceptor$(receiver) {
      if (typeof receiver == "number") {
        if (Math.floor(receiver) == receiver)
          return J.JSInt.prototype;
        return J.JSNumNotInt.prototype;
      }
      if (typeof receiver == "string")
        return J.JSString.prototype;
      if (receiver == null)
        return J.JSNull.prototype;
      if (typeof receiver == "boolean")
        return J.JSBool.prototype;
      if (Array.isArray(receiver))
        return J.JSArray.prototype;
      if (typeof receiver == "object") {
        if (receiver instanceof A.Object) {
          return receiver;
        } else {
          return J.JavaScriptObject.prototype;
        }
      }
      if (!(receiver instanceof A.Object))
        return J.UnknownJavaScriptObject.prototype;
      return receiver;
    },
    getInterceptor$as(receiver) {
      if (typeof receiver == "string")
        return J.JSString.prototype;
      if (receiver == null)
        return receiver;
      if (Array.isArray(receiver))
        return J.JSArray.prototype;
      if (!(receiver instanceof A.Object))
        return J.UnknownJavaScriptObject.prototype;
      return receiver;
    },
    get$length$as(receiver) {
      return J.getInterceptor$as(receiver).get$length(receiver);
    },
    get$runtimeType$(receiver) {
      return J.getInterceptor$(receiver).get$runtimeType(receiver);
    },
    toString$0$(receiver) {
      return J.getInterceptor$(receiver).toString$0(receiver);
    },
    Interceptor: function Interceptor() {
    },
    JSBool: function JSBool() {
    },
    JSNull: function JSNull() {
    },
    JavaScriptObject: function JavaScriptObject() {
    },
    LegacyJavaScriptObject: function LegacyJavaScriptObject() {
    },
    PlainJavaScriptObject: function PlainJavaScriptObject() {
    },
    UnknownJavaScriptObject: function UnknownJavaScriptObject() {
    },
    JSArray: function JSArray(t0) {
      this.$ti = t0;
    },
    JSUnmodifiableArray: function JSUnmodifiableArray(t0) {
      this.$ti = t0;
    },
    ArrayIterator: function ArrayIterator(t0, t1, t2) {
      var _ = this;
      _._iterable = t0;
      _._length = t1;
      _._index = 0;
      _._current = null;
      _.$ti = t2;
    },
    JSNumber: function JSNumber() {
    },
    JSInt: function JSInt() {
    },
    JSNumNotInt: function JSNumNotInt() {
    },
    JSString: function JSString() {
    }
  },
    A = {
      JS_CONST: function JS_CONST() {
      },
      checkNotNullable(value, $name, $T) {
        return value;
      },
      isToStringVisiting(object) {
        var t1, i;
        for (t1 = $.toStringVisiting.length, i = 0; i < t1; ++i)
          if (object === $.toStringVisiting[i])
            return true;
        return false;
      },
      LateError: function LateError(t0) {
        this._message = t0;
      },
      unminifyOrTag(rawClassName) {
        var preserved = init.mangledGlobalNames[rawClassName];
        if (preserved != null)
          return preserved;
        return rawClassName;
      },
      S(value) {
        var result;
        if (typeof value == "string")
          return value;
        if (typeof value == "number") {
          if (value !== 0)
            return "" + value;
        } else if (true === value)
          return "true";
        else if (false === value)
          return "false";
        else if (value == null)
          return "null";
        result = J.toString$0$(value);
        return result;
      },
      Primitives_objectTypeName(object) {
        return A.Primitives__objectTypeNameNewRti(object);
      },
      Primitives__objectTypeNameNewRti(object) {
        var interceptor, dispatchName, $constructor, constructorName;
        if (object instanceof A.Object)
          return A._rtiToString(A.instanceType(object), null);
        interceptor = J.getInterceptor$(object);
        if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) {
          dispatchName = B.C_JS_CONST(object);
          if (dispatchName !== "Object" && dispatchName !== "")
            return dispatchName;
          $constructor = object.constructor;
          if (typeof $constructor == "function") {
            constructorName = $constructor.name;
            if (typeof constructorName == "string" && constructorName !== "Object" && constructorName !== "")
              return constructorName;
          }
        }
        return A._rtiToString(A.instanceType(object), null);
      },
      Primitives_safeToString(object) {
        if (typeof object == "number" || A._isBool(object))
          return J.toString$0$(object);
        if (typeof object == "string")
          return JSON.stringify(object);
        if (object instanceof A.Closure)
          return object.toString$0(0);
        return "Instance of '" + A.Primitives_objectTypeName(object) + "'";
      },
      ioore(receiver, index) {
        if (receiver == null)
          J.get$length$as(receiver);
        throw A.wrapException(A.diagnoseIndexError(receiver, index));
      },
      diagnoseIndexError(indexable, index) {
        var $length, _s5_ = "index";
        if (!A._isInt(index))
          return new A.ArgumentError(true, index, _s5_, null);
        $length = J.get$length$as(indexable);
        if (index < 0 || index >= $length)
          return new A.IndexError($length, true, index, _s5_, "Index out of range");
        return new A.RangeError(true, index, _s5_, "Value not in range");
      },
      wrapException(ex) {
        return A.initializeExceptionWrapper(new Error(), ex);
      },
      initializeExceptionWrapper(wrapper, ex) {
        var t1;
        if (ex == null)
          ex = new A.TypeError();
        wrapper.dartException = ex;
        t1 = A.toStringWrapper;
        if ("defineProperty" in Object) {
          Object.defineProperty(wrapper, "message", { get: t1 });
          wrapper.name = "";
        } else
          wrapper.toString = t1;
        return wrapper;
      },
      toStringWrapper() {
        return J.toString$0$(this.dartException);
      },
      throwExpression(ex) {
        throw A.wrapException(ex);
      },
      throwExpressionWithWrapper(ex, wrapper) {
        throw A.initializeExceptionWrapper(wrapper, ex);
      },
      throwConcurrentModificationError(collection) {
        throw A.wrapException(new A.ConcurrentModificationError(collection));
      },
      TypeErrorDecoder_extractPattern(message) {
        var match, $arguments, argumentsExpr, expr, method, receiver;
        message = A.quoteStringForRegExp(message.replace(String({}), "$receiver$"));
        match = message.match(/\\\$[a-zA-Z]+\\\$/g);
        if (match == null)
          match = A._setArrayType([], type$.JSArray_String);
        $arguments = match.indexOf("\\$arguments\\$");
        argumentsExpr = match.indexOf("\\$argumentsExpr\\$");
        expr = match.indexOf("\\$expr\\$");
        method = match.indexOf("\\$method\\$");
        receiver = match.indexOf("\\$receiver\\$");
        return new A.TypeErrorDecoder(message.replace(new RegExp("\\\\\\$arguments\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$argumentsExpr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$expr\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$method\\\\\\$", "g"), "((?:x|[^x])*)").replace(new RegExp("\\\\\\$receiver\\\\\\$", "g"), "((?:x|[^x])*)"), $arguments, argumentsExpr, expr, method, receiver);
      },
      TypeErrorDecoder_provokeCallErrorOn(expression) {
        return function ($expr$) {
          var $argumentsExpr$ = "$arguments$";
          try {
            $expr$.$method$($argumentsExpr$);
          } catch (e) {
            return e.message;
          }
        }(expression);
      },
      TypeErrorDecoder_provokePropertyErrorOn(expression) {
        return function ($expr$) {
          try {
            $expr$.$method$;
          } catch (e) {
            return e.message;
          }
        }(expression);
      },
      JsNoSuchMethodError$(_message, match) {
        var t1 = match == null,
          t2 = t1 ? null : match.method;
        return new A.JsNoSuchMethodError(_message, t2, t1 ? null : match.receiver);
      },
      unwrapException(ex) {
        if (ex == null)
          return new A.NullThrownFromJavaScriptException(ex);
        if (typeof ex !== "object")
          return ex;
        if ("dartException" in ex)
          return A.saveStackTrace(ex, ex.dartException);
        return A._unwrapNonDartException(ex);
      },
      saveStackTrace(ex, error) {
        if (type$.Error._is(error))
          if (error.$thrownJsError == null)
            error.$thrownJsError = ex;
        return error;
      },
      _unwrapNonDartException(ex) {
        var message, number, ieErrorCode, nsme, notClosure, nullCall, nullLiteralCall, undefCall, undefLiteralCall, nullProperty, undefProperty, undefLiteralProperty, match;
        if (!("message" in ex))
          return ex;
        message = ex.message;
        if ("number" in ex && typeof ex.number == "number") {
          number = ex.number;
          ieErrorCode = number & 65535;
          if ((B.JSInt_methods._shrOtherPositive$1(number, 16) & 8191) === 10)
            switch (ieErrorCode) {
              case 438:
                return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A.S(message) + " (Error " + ieErrorCode + ")", null));
              case 445:
              case 5007:
                A.S(message);
                return A.saveStackTrace(ex, new A.NullError());
            }
        }
        if (ex instanceof TypeError) {
          nsme = $.$get$TypeErrorDecoder_noSuchMethodPattern();
          notClosure = $.$get$TypeErrorDecoder_notClosurePattern();
          nullCall = $.$get$TypeErrorDecoder_nullCallPattern();
          nullLiteralCall = $.$get$TypeErrorDecoder_nullLiteralCallPattern();
          undefCall = $.$get$TypeErrorDecoder_undefinedCallPattern();
          undefLiteralCall = $.$get$TypeErrorDecoder_undefinedLiteralCallPattern();
          nullProperty = $.$get$TypeErrorDecoder_nullPropertyPattern();
          $.$get$TypeErrorDecoder_nullLiteralPropertyPattern();
          undefProperty = $.$get$TypeErrorDecoder_undefinedPropertyPattern();
          undefLiteralProperty = $.$get$TypeErrorDecoder_undefinedLiteralPropertyPattern();
          match = nsme.matchTypeError$1(message);
          if (match != null)
            return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
          else {
            match = notClosure.matchTypeError$1(message);
            if (match != null) {
              match.method = "call";
              return A.saveStackTrace(ex, A.JsNoSuchMethodError$(A._asString(message), match));
            } else if (nullCall.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefCall.matchTypeError$1(message) != null || undefLiteralCall.matchTypeError$1(message) != null || nullProperty.matchTypeError$1(message) != null || nullLiteralCall.matchTypeError$1(message) != null || undefProperty.matchTypeError$1(message) != null || undefLiteralProperty.matchTypeError$1(message) != null) {
              A._asString(message);
              return A.saveStackTrace(ex, new A.NullError());
            }
          }
          return A.saveStackTrace(ex, new A.UnknownJsTypeError(typeof message == "string" ? message : ""));
        }
        if (ex instanceof RangeError) {
          if (typeof message == "string" && message.indexOf("call stack") !== -1)
            return new A.StackOverflowError();
          message = function (ex) {
            try {
              return String(ex);
            } catch (e) {
            }
            return null;
          }(ex);
          return A.saveStackTrace(ex, new A.ArgumentError(false, null, null, typeof message == "string" ? message.replace(/^RangeError:\s*/, "") : message));
        }
        if (typeof InternalError == "function" && ex instanceof InternalError)
          if (typeof message == "string" && message === "too much recursion")
            return new A.StackOverflowError();
        return ex;
      },
      getTraceFromException(exception) {
        var trace;
        if (exception == null)
          return new A._StackTrace(exception);
        trace = exception.$cachedTrace;
        if (trace != null)
          return trace;
        trace = new A._StackTrace(exception);
        if (typeof exception === "object")
          exception.$cachedTrace = trace;
        return trace;
      },
      _invokeClosure(closure, numberOfArguments, arg1, arg2, arg3, arg4) {
        type$.Function._as(closure);
        switch (A._asInt(numberOfArguments)) {
          case 0:
            return closure.call$0();
          case 1:
            return closure.call$1(arg1);
          case 2:
            return closure.call$2(arg1, arg2);
          case 3:
            return closure.call$3(arg1, arg2, arg3);
          case 4:
            return closure.call$4(arg1, arg2, arg3, arg4);
        }
        throw A.wrapException(new A._Exception("Unsupported number of arguments for wrapped closure"));
      },
      convertDartClosureToJS(closure, arity) {
        var $function = closure.$identity;
        if (!!$function)
          return $function;
        $function = A.convertDartClosureToJSUncached(closure, arity);
        closure.$identity = $function;
        return $function;
      },
      convertDartClosureToJSUncached(closure, arity) {
        var entry;
        switch (arity) {
          case 0:
            entry = closure.call$0;
            break;
          case 1:
            entry = closure.call$1;
            break;
          case 2:
            entry = closure.call$2;
            break;
          case 3:
            entry = closure.call$3;
            break;
          case 4:
            entry = closure.call$4;
            break;
          default:
            entry = null;
        }
        if (entry != null)
          return entry.bind(closure);
        return function (closure, arity, invoke) {
          return function (a1, a2, a3, a4) {
            return invoke(closure, arity, a1, a2, a3, a4);
          };
        }(closure, arity, A._invokeClosure);
      },
      Closure_fromTearOff(parameters) {
        var $prototype, $constructor, t2, trampoline, applyTrampoline, i, stub, stub0, stubName, stubCallName,
          container = parameters.co,
          isStatic = parameters.iS,
          isIntercepted = parameters.iI,
          needsDirectAccess = parameters.nDA,
          applyTrampolineIndex = parameters.aI,
          funsOrNames = parameters.fs,
          callNames = parameters.cs,
          $name = funsOrNames[0],
          callName = callNames[0],
          $function = container[$name],
          t1 = parameters.fT;
        t1.toString;
        $prototype = isStatic ? Object.create(new A.StaticClosure().constructor.prototype) : Object.create(new A.BoundClosure(null, null).constructor.prototype);
        $prototype.$initialize = $prototype.constructor;
        $constructor = isStatic ? function static_tear_off() {
          this.$initialize();
        } : function tear_off(a, b) {
          this.$initialize(a, b);
        };
        $prototype.constructor = $constructor;
        $constructor.prototype = $prototype;
        $prototype.$_name = $name;
        $prototype.$_target = $function;
        t2 = !isStatic;
        if (t2)
          trampoline = A.Closure_forwardCallTo($name, $function, isIntercepted, needsDirectAccess);
        else {
          $prototype.$static_name = $name;
          trampoline = $function;
        }
        $prototype.$signature = A.Closure__computeSignatureFunctionNewRti(t1, isStatic, isIntercepted);
        $prototype[callName] = trampoline;
        for (applyTrampoline = trampoline, i = 1; i < funsOrNames.length; ++i) {
          stub = funsOrNames[i];
          if (typeof stub == "string") {
            stub0 = container[stub];
            stubName = stub;
            stub = stub0;
          } else
            stubName = "";
          stubCallName = callNames[i];
          if (stubCallName != null) {
            if (t2)
              stub = A.Closure_forwardCallTo(stubName, stub, isIntercepted, needsDirectAccess);
            $prototype[stubCallName] = stub;
          }
          if (i === applyTrampolineIndex)
            applyTrampoline = stub;
        }
        $prototype["call*"] = applyTrampoline;
        $prototype.$requiredArgCount = parameters.rC;
        $prototype.$defaultValues = parameters.dV;
        return $constructor;
      },
      Closure__computeSignatureFunctionNewRti(functionType, isStatic, isIntercepted) {
        if (typeof functionType == "number")
          return functionType;
        if (typeof functionType == "string") {
          if (isStatic)
            throw A.wrapException("Cannot compute signature for static tearoff.");
          return function (recipe, evalOnReceiver) {
            return function () {
              return evalOnReceiver(this, recipe);
            };
          }(functionType, A.BoundClosure_evalRecipe);
        }
        throw A.wrapException("Error in functionType of tearoff");
      },
      Closure_cspForwardCall(arity, needsDirectAccess, stubName, $function) {
        var getReceiver = A.BoundClosure_receiverOf;
        switch (needsDirectAccess ? -1 : arity) {
          case 0:
            return function (entry, receiverOf) {
              return function () {
                return receiverOf(this)[entry]();
              };
            }(stubName, getReceiver);
          case 1:
            return function (entry, receiverOf) {
              return function (a) {
                return receiverOf(this)[entry](a);
              };
            }(stubName, getReceiver);
          case 2:
            return function (entry, receiverOf) {
              return function (a, b) {
                return receiverOf(this)[entry](a, b);
              };
            }(stubName, getReceiver);
          case 3:
            return function (entry, receiverOf) {
              return function (a, b, c) {
                return receiverOf(this)[entry](a, b, c);
              };
            }(stubName, getReceiver);
          case 4:
            return function (entry, receiverOf) {
              return function (a, b, c, d) {
                return receiverOf(this)[entry](a, b, c, d);
              };
            }(stubName, getReceiver);
          case 5:
            return function (entry, receiverOf) {
              return function (a, b, c, d, e) {
                return receiverOf(this)[entry](a, b, c, d, e);
              };
            }(stubName, getReceiver);
          default:
            return function (f, receiverOf) {
              return function () {
                return f.apply(receiverOf(this), arguments);
              };
            }($function, getReceiver);
        }
      },
      Closure_forwardCallTo(stubName, $function, isIntercepted, needsDirectAccess) {
        if (isIntercepted)
          return A.Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess);
        return A.Closure_cspForwardCall($function.length, needsDirectAccess, stubName, $function);
      },
      Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function) {
        var getReceiver = A.BoundClosure_receiverOf,
          getInterceptor = A.BoundClosure_interceptorOf;
        switch (needsDirectAccess ? -1 : arity) {
          case 0:
            throw A.wrapException(new A.RuntimeError("Intercepted function with no arguments."));
          case 1:
            return function (entry, interceptorOf, receiverOf) {
              return function () {
                return interceptorOf(this)[entry](receiverOf(this));
              };
            }(stubName, getInterceptor, getReceiver);
          case 2:
            return function (entry, interceptorOf, receiverOf) {
              return function (a) {
                return interceptorOf(this)[entry](receiverOf(this), a);
              };
            }(stubName, getInterceptor, getReceiver);
          case 3:
            return function (entry, interceptorOf, receiverOf) {
              return function (a, b) {
                return interceptorOf(this)[entry](receiverOf(this), a, b);
              };
            }(stubName, getInterceptor, getReceiver);
          case 4:
            return function (entry, interceptorOf, receiverOf) {
              return function (a, b, c) {
                return interceptorOf(this)[entry](receiverOf(this), a, b, c);
              };
            }(stubName, getInterceptor, getReceiver);
          case 5:
            return function (entry, interceptorOf, receiverOf) {
              return function (a, b, c, d) {
                return interceptorOf(this)[entry](receiverOf(this), a, b, c, d);
              };
            }(stubName, getInterceptor, getReceiver);
          case 6:
            return function (entry, interceptorOf, receiverOf) {
              return function (a, b, c, d, e) {
                return interceptorOf(this)[entry](receiverOf(this), a, b, c, d, e);
              };
            }(stubName, getInterceptor, getReceiver);
          default:
            return function (f, interceptorOf, receiverOf) {
              return function () {
                var a = [receiverOf(this)];
                Array.prototype.push.apply(a, arguments);
                return f.apply(interceptorOf(this), a);
              };
            }($function, getInterceptor, getReceiver);
        }
      },
      Closure_forwardInterceptedCallTo(stubName, $function, needsDirectAccess) {
        var arity, t1;
        if ($.BoundClosure__interceptorFieldNameCache == null)
          $.BoundClosure__interceptorFieldNameCache = A.BoundClosure__computeFieldNamed("interceptor");
        if ($.BoundClosure__receiverFieldNameCache == null)
          $.BoundClosure__receiverFieldNameCache = A.BoundClosure__computeFieldNamed("receiver");
        arity = $function.length;
        t1 = A.Closure_cspForwardInterceptedCall(arity, needsDirectAccess, stubName, $function);
        return t1;
      },
      closureFromTearOff(parameters) {
        return A.Closure_fromTearOff(parameters);
      },
      BoundClosure_evalRecipe(closure, recipe) {
        return A._Universe_evalInEnvironment(init.typeUniverse, A.instanceType(closure._receiver), recipe);
      },
      BoundClosure_receiverOf(closure) {
        return closure._receiver;
      },
      BoundClosure_interceptorOf(closure) {
        return closure._interceptor;
      },
      BoundClosure__computeFieldNamed(fieldName) {
        var names, i, $name,
          template = new A.BoundClosure("receiver", "interceptor"),
          t1 = Object.getOwnPropertyNames(template);
        t1.fixed$length = Array;
        names = t1;
        for (t1 = names.length, i = 0; i < t1; ++i) {
          $name = names[i];
          if (template[$name] === fieldName)
            return $name;
        }
        throw A.wrapException(A.ArgumentError$("Field name " + fieldName + " not found.", null));
      },
      throwCyclicInit(staticName) {
        throw A.wrapException(new A._CyclicInitializationError(staticName));
      },
      createRecordTypePredicate(shape, fieldRtis) {
        var $length = fieldRtis.length,
          $function = init.rttc["" + $length + ";" + shape];
        if ($function == null)
          return null;
        if ($length === 0)
          return $function;
        if ($length === $function.length)
          return $function.apply(null, fieldRtis);
        return $function(fieldRtis);
      },
      quoteStringForRegExp(string) {
        if (/[[\]{}()*+?.\\^$|]/.test(string))
          return string.replace(/[[\]{}()*+?.\\^$|]/g, "\\$&");
        return string;
      },
      TypeErrorDecoder: function TypeErrorDecoder(t0, t1, t2, t3, t4, t5) {
        var _ = this;
        _._pattern = t0;
        _._arguments = t1;
        _._argumentsExpr = t2;
        _._expr = t3;
        _._method = t4;
        _._receiver = t5;
      },
      NullError: function NullError() {
      },
      JsNoSuchMethodError: function JsNoSuchMethodError(t0, t1, t2) {
        this.__js_helper$_message = t0;
        this._method = t1;
        this._receiver = t2;
      },
      UnknownJsTypeError: function UnknownJsTypeError(t0) {
        this.__js_helper$_message = t0;
      },
      NullThrownFromJavaScriptException: function NullThrownFromJavaScriptException(t0) {
        this._irritant = t0;
      },
      _StackTrace: function _StackTrace(t0) {
        this._exception = t0;
        this._trace = null;
      },
      Closure: function Closure() {
      },
      Closure0Args: function Closure0Args() {
      },
      Closure2Args: function Closure2Args() {
      },
      TearOffClosure: function TearOffClosure() {
      },
      StaticClosure: function StaticClosure() {
      },
      BoundClosure: function BoundClosure(t0, t1) {
        this._receiver = t0;
        this._interceptor = t1;
      },
      _CyclicInitializationError: function _CyclicInitializationError(t0) {
        this.variableName = t0;
      },
      RuntimeError: function RuntimeError(t0) {
        this.message = t0;
      },
      Rti__getQuestionFromStar(universe, rti) {
        var question = rti._precomputed1;
        return question == null ? rti._precomputed1 = A._Universe__lookupQuestionRti(universe, rti._primary, true) : question;
      },
      Rti__getFutureFromFutureOr(universe, rti) {
        var future = rti._precomputed1;
        return future == null ? rti._precomputed1 = A._Universe__lookupInterfaceRti(universe, "Future", [rti._primary]) : future;
      },
      Rti__isUnionOfFunctionType(rti) {
        var kind = rti._kind;
        if (kind === 6 || kind === 7 || kind === 8)
          return A.Rti__isUnionOfFunctionType(rti._primary);
        return kind === 12 || kind === 13;
      },
      Rti__getCanonicalRecipe(rti) {
        return rti._canonicalRecipe;
      },
      findType(recipe) {
        return A._Universe_eval(init.typeUniverse, recipe, false);
      },
      _substitute(universe, rti, typeArguments, depth) {
        var baseType, substitutedBaseType, interfaceTypeArguments, substitutedInterfaceTypeArguments, base, substitutedBase, $arguments, substitutedArguments, t1, fields, substitutedFields, returnType, substitutedReturnType, functionParameters, substitutedFunctionParameters, bounds, substitutedBounds, index, argument,
          kind = rti._kind;
        switch (kind) {
          case 5:
          case 1:
          case 2:
          case 3:
          case 4:
            return rti;
          case 6:
            baseType = rti._primary;
            substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
            if (substitutedBaseType === baseType)
              return rti;
            return A._Universe__lookupStarRti(universe, substitutedBaseType, true);
          case 7:
            baseType = rti._primary;
            substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
            if (substitutedBaseType === baseType)
              return rti;
            return A._Universe__lookupQuestionRti(universe, substitutedBaseType, true);
          case 8:
            baseType = rti._primary;
            substitutedBaseType = A._substitute(universe, baseType, typeArguments, depth);
            if (substitutedBaseType === baseType)
              return rti;
            return A._Universe__lookupFutureOrRti(universe, substitutedBaseType, true);
          case 9:
            interfaceTypeArguments = rti._rest;
            substitutedInterfaceTypeArguments = A._substituteArray(universe, interfaceTypeArguments, typeArguments, depth);
            if (substitutedInterfaceTypeArguments === interfaceTypeArguments)
              return rti;
            return A._Universe__lookupInterfaceRti(universe, rti._primary, substitutedInterfaceTypeArguments);
          case 10:
            base = rti._primary;
            substitutedBase = A._substitute(universe, base, typeArguments, depth);
            $arguments = rti._rest;
            substitutedArguments = A._substituteArray(universe, $arguments, typeArguments, depth);
            if (substitutedBase === base && substitutedArguments === $arguments)
              return rti;
            return A._Universe__lookupBindingRti(universe, substitutedBase, substitutedArguments);
          case 11:
            t1 = rti._primary;
            fields = rti._rest;
            substitutedFields = A._substituteArray(universe, fields, typeArguments, depth);
            if (substitutedFields === fields)
              return rti;
            return A._Universe__lookupRecordRti(universe, t1, substitutedFields);
          case 12:
            returnType = rti._primary;
            substitutedReturnType = A._substitute(universe, returnType, typeArguments, depth);
            functionParameters = rti._rest;
            substitutedFunctionParameters = A._substituteFunctionParameters(universe, functionParameters, typeArguments, depth);
            if (substitutedReturnType === returnType && substitutedFunctionParameters === functionParameters)
              return rti;
            return A._Universe__lookupFunctionRti(universe, substitutedReturnType, substitutedFunctionParameters);
          case 13:
            bounds = rti._rest;
            depth += bounds.length;
            substitutedBounds = A._substituteArray(universe, bounds, typeArguments, depth);
            base = rti._primary;
            substitutedBase = A._substitute(universe, base, typeArguments, depth);
            if (substitutedBounds === bounds && substitutedBase === base)
              return rti;
            return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, true);
          case 14:
            index = rti._primary;
            if (index < depth)
              return rti;
            argument = typeArguments[index - depth];
            if (argument == null)
              return rti;
            return argument;
          default:
            throw A.wrapException(A.AssertionError$("Attempted to substitute unexpected RTI kind " + kind));
        }
      },
      _substituteArray(universe, rtiArray, typeArguments, depth) {
        var changed, i, rti, substitutedRti,
          $length = rtiArray.length,
          result = A._Utils_newArrayOrEmpty($length);
        for (changed = false, i = 0; i < $length; ++i) {
          rti = rtiArray[i];
          substitutedRti = A._substitute(universe, rti, typeArguments, depth);
          if (substitutedRti !== rti)
            changed = true;
          result[i] = substitutedRti;
        }
        return changed ? result : rtiArray;
      },
      _substituteNamed(universe, namedArray, typeArguments, depth) {
        var changed, i, t1, t2, rti, substitutedRti,
          $length = namedArray.length,
          result = A._Utils_newArrayOrEmpty($length);
        for (changed = false, i = 0; i < $length; i += 3) {
          t1 = namedArray[i];
          t2 = namedArray[i + 1];
          rti = namedArray[i + 2];
          substitutedRti = A._substitute(universe, rti, typeArguments, depth);
          if (substitutedRti !== rti)
            changed = true;
          result.splice(i, 3, t1, t2, substitutedRti);
        }
        return changed ? result : namedArray;
      },
      _substituteFunctionParameters(universe, functionParameters, typeArguments, depth) {
        var result,
          requiredPositional = functionParameters._requiredPositional,
          substitutedRequiredPositional = A._substituteArray(universe, requiredPositional, typeArguments, depth),
          optionalPositional = functionParameters._optionalPositional,
          substitutedOptionalPositional = A._substituteArray(universe, optionalPositional, typeArguments, depth),
          named = functionParameters._named,
          substitutedNamed = A._substituteNamed(universe, named, typeArguments, depth);
        if (substitutedRequiredPositional === requiredPositional && substitutedOptionalPositional === optionalPositional && substitutedNamed === named)
          return functionParameters;
        result = new A._FunctionParameters();
        result._requiredPositional = substitutedRequiredPositional;
        result._optionalPositional = substitutedOptionalPositional;
        result._named = substitutedNamed;
        return result;
      },
      _setArrayType(target, rti) {
        target[init.arrayRti] = rti;
        return target;
      },
      closureFunctionType(closure) {
        var signature = closure.$signature;
        if (signature != null) {
          if (typeof signature == "number")
            return A.getTypeFromTypesTable(signature);
          return closure.$signature();
        }
        return null;
      },
      instanceOrFunctionType(object, testRti) {
        var rti;
        if (A.Rti__isUnionOfFunctionType(testRti))
          if (object instanceof A.Closure) {
            rti = A.closureFunctionType(object);
            if (rti != null)
              return rti;
          }
        return A.instanceType(object);
      },
      instanceType(object) {
        if (object instanceof A.Object)
          return A._instanceType(object);
        if (Array.isArray(object))
          return A._arrayInstanceType(object);
        return A._instanceTypeFromConstructor(J.getInterceptor$(object));
      },
      _arrayInstanceType(object) {
        var rti = object[init.arrayRti],
          defaultRti = type$.JSArray_dynamic;
        if (rti == null)
          return defaultRti;
        if (rti.constructor !== defaultRti.constructor)
          return defaultRti;
        return rti;
      },
      _instanceType(object) {
        var rti = object.$ti;
        return rti != null ? rti : A._instanceTypeFromConstructor(object);
      },
      _instanceTypeFromConstructor(instance) {
        var $constructor = instance.constructor,
          probe = $constructor.$ccache;
        if (probe != null)
          return probe;
        return A._instanceTypeFromConstructorMiss(instance, $constructor);
      },
      _instanceTypeFromConstructorMiss(instance, $constructor) {
        var effectiveConstructor = instance instanceof A.Closure ? Object.getPrototypeOf(Object.getPrototypeOf(instance)).constructor : $constructor,
          rti = A._Universe_findErasedType(init.typeUniverse, effectiveConstructor.name);
        $constructor.$ccache = rti;
        return rti;
      },
      getTypeFromTypesTable(index) {
        var rti,
          table = init.types,
          type = table[index];
        if (typeof type == "string") {
          rti = A._Universe_eval(init.typeUniverse, type, false);
          table[index] = rti;
          return rti;
        }
        return type;
      },
      getRuntimeTypeOfDartObject(object) {
        return A.createRuntimeType(A._instanceType(object));
      },
      _structuralTypeOf(object) {
        var functionRti = object instanceof A.Closure ? A.closureFunctionType(object) : null;
        if (functionRti != null)
          return functionRti;
        if (type$.TrustedGetRuntimeType._is(object))
          return J.get$runtimeType$(object)._rti;
        if (Array.isArray(object))
          return A._arrayInstanceType(object);
        return A.instanceType(object);
      },
      createRuntimeType(rti) {
        var t1 = rti._cachedRuntimeType;
        return t1 == null ? rti._cachedRuntimeType = A._createRuntimeType(rti) : t1;
      },
      _createRuntimeType(rti) {
        var starErasedRti, t1,
          s = rti._canonicalRecipe,
          starErasedRecipe = s.replace(/\*/g, "");
        if (starErasedRecipe === s)
          return rti._cachedRuntimeType = new A._Type(rti);
        starErasedRti = A._Universe_eval(init.typeUniverse, starErasedRecipe, true);
        t1 = starErasedRti._cachedRuntimeType;
        return t1 == null ? starErasedRti._cachedRuntimeType = A._createRuntimeType(starErasedRti) : t1;
      },
      _installSpecializedIsTest(object) {
        var t1, unstarred, unstarredKind, isFn, $name, predicate, testRti = this;
        if (testRti === type$.Object)
          return A._finishIsFn(testRti, object, A._isObject);
        if (!A.isSoundTopType(testRti))
          if (!(testRti === type$.legacy_Object))
            t1 = false;
          else
            t1 = true;
        else
          t1 = true;
        if (t1)
          return A._finishIsFn(testRti, object, A._isTop);
        t1 = testRti._kind;
        if (t1 === 7)
          return A._finishIsFn(testRti, object, A._generalNullableIsTestImplementation);
        if (t1 === 1)
          return A._finishIsFn(testRti, object, A._isNever);
        unstarred = t1 === 6 ? testRti._primary : testRti;
        unstarredKind = unstarred._kind;
        if (unstarredKind === 8)
          return A._finishIsFn(testRti, object, A._isFutureOr);
        if (unstarred === type$.int)
          isFn = A._isInt;
        else if (unstarred === type$.double || unstarred === type$.num)
          isFn = A._isNum;
        else if (unstarred === type$.String)
          isFn = A._isString;
        else
          isFn = unstarred === type$.bool ? A._isBool : null;
        if (isFn != null)
          return A._finishIsFn(testRti, object, isFn);
        if (unstarredKind === 9) {
          $name = unstarred._primary;
          if (unstarred._rest.every(A.isDefinitelyTopType)) {
            testRti._specializedTestResource = "$is" + $name;
            if ($name === "List")
              return A._finishIsFn(testRti, object, A._isListTestViaProperty);
            return A._finishIsFn(testRti, object, A._isTestViaProperty);
          }
        } else if (unstarredKind === 11) {
          predicate = A.createRecordTypePredicate(unstarred._primary, unstarred._rest);
          return A._finishIsFn(testRti, object, predicate == null ? A._isNever : predicate);
        }
        return A._finishIsFn(testRti, object, A._generalIsTestImplementation);
      },
      _finishIsFn(testRti, object, isFn) {
        testRti._is = isFn;
        return testRti._is(object);
      },
      _installSpecializedAsCheck(object) {
        var t1, testRti = this,
          asFn = A._generalAsCheckImplementation;
        if (!A.isSoundTopType(testRti))
          if (!(testRti === type$.legacy_Object))
            t1 = false;
          else
            t1 = true;
        else
          t1 = true;
        if (t1)
          asFn = A._asTop;
        else if (testRti === type$.Object)
          asFn = A._asObject;
        else {
          t1 = A.isNullable(testRti);
          if (t1)
            asFn = A._generalNullableAsCheckImplementation;
        }
        testRti._as = asFn;
        return testRti._as(object);
      },
      _nullIs(testRti) {
        var t1,
          kind = testRti._kind;
        if (!A.isSoundTopType(testRti))
          if (!(testRti === type$.legacy_Object))
            if (!(testRti === type$.legacy_Never))
              if (kind !== 7)
                if (!(kind === 6 && A._nullIs(testRti._primary)))
                  t1 = kind === 8 && A._nullIs(testRti._primary) || testRti === type$.Null || testRti === type$.JSNull;
                else
                  t1 = true;
              else
                t1 = true;
            else
              t1 = true;
          else
            t1 = true;
        else
          t1 = true;
        return t1;
      },
      _generalIsTestImplementation(object) {
        var testRti = this;
        if (object == null)
          return A._nullIs(testRti);
        return A.isSubtype(init.typeUniverse, A.instanceOrFunctionType(object, testRti), testRti);
      },
      _generalNullableIsTestImplementation(object) {
        if (object == null)
          return true;
        return this._primary._is(object);
      },
      _isTestViaProperty(object) {
        var tag, testRti = this;
        if (object == null)
          return A._nullIs(testRti);
        tag = testRti._specializedTestResource;
        if (object instanceof A.Object)
          return !!object[tag];
        return !!J.getInterceptor$(object)[tag];
      },
      _isListTestViaProperty(object) {
        var tag, testRti = this;
        if (object == null)
          return A._nullIs(testRti);
        if (typeof object != "object")
          return false;
        if (Array.isArray(object))
          return true;
        tag = testRti._specializedTestResource;
        if (object instanceof A.Object)
          return !!object[tag];
        return !!J.getInterceptor$(object)[tag];
      },
      _generalAsCheckImplementation(object) {
        var testRti = this;
        if (object == null) {
          if (A.isNullable(testRti))
            return object;
        } else if (testRti._is(object))
          return object;
        A._failedAsCheck(object, testRti);
      },
      _generalNullableAsCheckImplementation(object) {
        var testRti = this;
        if (object == null)
          return object;
        else if (testRti._is(object))
          return object;
        A._failedAsCheck(object, testRti);
      },
      _failedAsCheck(object, testRti) {
        throw A.wrapException(A._TypeError$fromMessage(A._Error_compose(object, A._rtiToString(testRti, null))));
      },
      _Error_compose(object, checkedTypeDescription) {
        return A.Error_safeToString(object) + ": type '" + A._rtiToString(A._structuralTypeOf(object), null) + "' is not a subtype of type '" + checkedTypeDescription + "'";
      },
      _TypeError$fromMessage(message) {
        return new A._TypeError("TypeError: " + message);
      },
      _TypeError__TypeError$forType(object, type) {
        return new A._TypeError("TypeError: " + A._Error_compose(object, type));
      },
      _isFutureOr(object) {
        var testRti = this,
          unstarred = testRti._kind === 6 ? testRti._primary : testRti;
        return unstarred._primary._is(object) || A.Rti__getFutureFromFutureOr(init.typeUniverse, unstarred)._is(object);
      },
      _isObject(object) {
        return object != null;
      },
      _asObject(object) {
        if (object != null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "Object"));
      },
      _isTop(object) {
        return true;
      },
      _asTop(object) {
        return object;
      },
      _isNever(object) {
        return false;
      },
      _isBool(object) {
        return true === object || false === object;
      },
      _asBool(object) {
        if (true === object)
          return true;
        if (false === object)
          return false;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
      },
      _asBoolS(object) {
        if (true === object)
          return true;
        if (false === object)
          return false;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "bool"));
      },
      _asBoolQ(object) {
        if (true === object)
          return true;
        if (false === object)
          return false;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "bool?"));
      },
      _asDouble(object) {
        if (typeof object == "number")
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
      },
      _asDoubleS(object) {
        if (typeof object == "number")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "double"));
      },
      _asDoubleQ(object) {
        if (typeof object == "number")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "double?"));
      },
      _isInt(object) {
        return typeof object == "number" && Math.floor(object) === object;
      },
      _asInt(object) {
        if (typeof object == "number" && Math.floor(object) === object)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
      },
      _asIntS(object) {
        if (typeof object == "number" && Math.floor(object) === object)
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "int"));
      },
      _asIntQ(object) {
        if (typeof object == "number" && Math.floor(object) === object)
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "int?"));
      },
      _isNum(object) {
        return typeof object == "number";
      },
      _asNum(object) {
        if (typeof object == "number")
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
      },
      _asNumS(object) {
        if (typeof object == "number")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "num"));
      },
      _asNumQ(object) {
        if (typeof object == "number")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "num?"));
      },
      _isString(object) {
        return typeof object == "string";
      },
      _asString(object) {
        if (typeof object == "string")
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
      },
      _asStringS(object) {
        if (typeof object == "string")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "String"));
      },
      _asStringQ(object) {
        if (typeof object == "string")
          return object;
        if (object == null)
          return object;
        throw A.wrapException(A._TypeError__TypeError$forType(object, "String?"));
      },
      _rtiArrayToString(array, genericContext) {
        var s, sep, i;
        for (s = "", sep = "", i = 0; i < array.length; ++i, sep = ", ")
          s += sep + A._rtiToString(array[i], genericContext);
        return s;
      },
      _recordRtiToString(recordType, genericContext) {
        var fieldCount, names, namesIndex, s, comma, i,
          partialShape = recordType._primary,
          fields = recordType._rest;
        if ("" === partialShape)
          return "(" + A._rtiArrayToString(fields, genericContext) + ")";
        fieldCount = fields.length;
        names = partialShape.split(",");
        namesIndex = names.length - fieldCount;
        for (s = "(", comma = "", i = 0; i < fieldCount; ++i, comma = ", ") {
          s += comma;
          if (namesIndex === 0)
            s += "{";
          s += A._rtiToString(fields[i], genericContext);
          if (namesIndex >= 0)
            s += " " + names[namesIndex];
          ++namesIndex;
        }
        return s + "})";
      },
      _functionRtiToString(functionType, genericContext, bounds) {
        var boundsLength, outerContextLength, offset, i, t1, t2, typeParametersText, typeSep, t3, t4, boundRti, kind, parameters, requiredPositional, requiredPositionalLength, optionalPositional, optionalPositionalLength, named, namedLength, returnTypeText, argumentsText, sep, _s2_ = ", ";
        if (bounds != null) {
          boundsLength = bounds.length;
          if (genericContext == null) {
            genericContext = A._setArrayType([], type$.JSArray_String);
            outerContextLength = null;
          } else
            outerContextLength = genericContext.length;
          offset = genericContext.length;
          for (i = boundsLength; i > 0; --i)
            B.JSArray_methods.add$1(genericContext, "T" + (offset + i));
          for (t1 = type$.nullable_Object, t2 = type$.legacy_Object, typeParametersText = "<", typeSep = "", i = 0; i < boundsLength; ++i, typeSep = _s2_) {
            t3 = genericContext.length;
            t4 = t3 - 1 - i;
            if (!(t4 >= 0))
              return A.ioore(genericContext, t4);
            typeParametersText = B.JSString_methods.$add(typeParametersText + typeSep, genericContext[t4]);
            boundRti = bounds[i];
            kind = boundRti._kind;
            if (!(kind === 2 || kind === 3 || kind === 4 || kind === 5 || boundRti === t1))
              if (!(boundRti === t2))
                t3 = false;
              else
                t3 = true;
            else
              t3 = true;
            if (!t3)
              typeParametersText += " extends " + A._rtiToString(boundRti, genericContext);
          }
          typeParametersText += ">";
        } else {
          typeParametersText = "";
          outerContextLength = null;
        }
        t1 = functionType._primary;
        parameters = functionType._rest;
        requiredPositional = parameters._requiredPositional;
        requiredPositionalLength = requiredPositional.length;
        optionalPositional = parameters._optionalPositional;
        optionalPositionalLength = optionalPositional.length;
        named = parameters._named;
        namedLength = named.length;
        returnTypeText = A._rtiToString(t1, genericContext);
        for (argumentsText = "", sep = "", i = 0; i < requiredPositionalLength; ++i, sep = _s2_)
          argumentsText += sep + A._rtiToString(requiredPositional[i], genericContext);
        if (optionalPositionalLength > 0) {
          argumentsText += sep + "[";
          for (sep = "", i = 0; i < optionalPositionalLength; ++i, sep = _s2_)
            argumentsText += sep + A._rtiToString(optionalPositional[i], genericContext);
          argumentsText += "]";
        }
        if (namedLength > 0) {
          argumentsText += sep + "{";
          for (sep = "", i = 0; i < namedLength; i += 3, sep = _s2_) {
            argumentsText += sep;
            if (named[i + 1])
              argumentsText += "required ";
            argumentsText += A._rtiToString(named[i + 2], genericContext) + " " + named[i];
          }
          argumentsText += "}";
        }
        if (outerContextLength != null) {
          genericContext.toString;
          genericContext.length = outerContextLength;
        }
        return typeParametersText + "(" + argumentsText + ") => " + returnTypeText;
      },
      _rtiToString(rti, genericContext) {
        var questionArgument, s, argumentKind, $name, $arguments, t1, t2,
          kind = rti._kind;
        if (kind === 5)
          return "erased";
        if (kind === 2)
          return "dynamic";
        if (kind === 3)
          return "void";
        if (kind === 1)
          return "Never";
        if (kind === 4)
          return "any";
        if (kind === 6)
          return A._rtiToString(rti._primary, genericContext);
        if (kind === 7) {
          questionArgument = rti._primary;
          s = A._rtiToString(questionArgument, genericContext);
          argumentKind = questionArgument._kind;
          return (argumentKind === 12 || argumentKind === 13 ? "(" + s + ")" : s) + "?";
        }
        if (kind === 8)
          return "FutureOr<" + A._rtiToString(rti._primary, genericContext) + ">";
        if (kind === 9) {
          $name = A._unminifyOrTag(rti._primary);
          $arguments = rti._rest;
          return $arguments.length > 0 ? $name + ("<" + A._rtiArrayToString($arguments, genericContext) + ">") : $name;
        }
        if (kind === 11)
          return A._recordRtiToString(rti, genericContext);
        if (kind === 12)
          return A._functionRtiToString(rti, genericContext, null);
        if (kind === 13)
          return A._functionRtiToString(rti._primary, genericContext, rti._rest);
        if (kind === 14) {
          t1 = rti._primary;
          t2 = genericContext.length;
          t1 = t2 - 1 - t1;
          if (!(t1 >= 0 && t1 < t2))
            return A.ioore(genericContext, t1);
          return genericContext[t1];
        }
        return "?";
      },
      _unminifyOrTag(rawClassName) {
        var preserved = init.mangledGlobalNames[rawClassName];
        if (preserved != null)
          return preserved;
        return rawClassName;
      },
      _Universe_findRule(universe, targetType) {
        var rule = universe.tR[targetType];
        for (; typeof rule == "string";)
          rule = universe.tR[rule];
        return rule;
      },
      _Universe_findErasedType(universe, cls) {
        var $length, erased, $arguments, i, $interface,
          t1 = universe.eT,
          probe = t1[cls];
        if (probe == null)
          return A._Universe_eval(universe, cls, false);
        else if (typeof probe == "number") {
          $length = probe;
          erased = A._Universe__lookupTerminalRti(universe, 5, "#");
          $arguments = A._Utils_newArrayOrEmpty($length);
          for (i = 0; i < $length; ++i)
            $arguments[i] = erased;
          $interface = A._Universe__lookupInterfaceRti(universe, cls, $arguments);
          t1[cls] = $interface;
          return $interface;
        } else
          return probe;
      },
      _Universe_addRules(universe, rules) {
        return A._Utils_objectAssign(universe.tR, rules);
      },
      _Universe_addErasedTypes(universe, types) {
        return A._Utils_objectAssign(universe.eT, types);
      },
      _Universe_eval(universe, recipe, normalize) {
        var rti,
          t1 = universe.eC,
          probe = t1.get(recipe);
        if (probe != null)
          return probe;
        rti = A._Parser_parse(A._Parser_create(universe, null, recipe, normalize));
        t1.set(recipe, rti);
        return rti;
      },
      _Universe_evalInEnvironment(universe, environment, recipe) {
        var probe, rti,
          cache = environment._evalCache;
        if (cache == null)
          cache = environment._evalCache = new Map();
        probe = cache.get(recipe);
        if (probe != null)
          return probe;
        rti = A._Parser_parse(A._Parser_create(universe, environment, recipe, true));
        cache.set(recipe, rti);
        return rti;
      },
      _Universe_bind(universe, environment, argumentsRti) {
        var argumentsRecipe, probe, rti,
          cache = environment._bindCache;
        if (cache == null)
          cache = environment._bindCache = new Map();
        argumentsRecipe = argumentsRti._canonicalRecipe;
        probe = cache.get(argumentsRecipe);
        if (probe != null)
          return probe;
        rti = A._Universe__lookupBindingRti(universe, environment, argumentsRti._kind === 10 ? argumentsRti._rest : [argumentsRti]);
        cache.set(argumentsRecipe, rti);
        return rti;
      },
      _Universe__installTypeTests(universe, rti) {
        rti._as = A._installSpecializedAsCheck;
        rti._is = A._installSpecializedIsTest;
        return rti;
      },
      _Universe__lookupTerminalRti(universe, kind, key) {
        var rti, t1,
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = kind;
        rti._canonicalRecipe = key;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__lookupStarRti(universe, baseType, normalize) {
        var t1,
          key = baseType._canonicalRecipe + "*",
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        t1 = A._Universe__createStarRti(universe, baseType, key, normalize);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__createStarRti(universe, baseType, key, normalize) {
        var baseKind, t1, rti;
        if (normalize) {
          baseKind = baseType._kind;
          if (!A.isSoundTopType(baseType))
            t1 = baseType === type$.Null || baseType === type$.JSNull || baseKind === 7 || baseKind === 6;
          else
            t1 = true;
          if (t1)
            return baseType;
        }
        rti = new A.Rti(null, null);
        rti._kind = 6;
        rti._primary = baseType;
        rti._canonicalRecipe = key;
        return A._Universe__installTypeTests(universe, rti);
      },
      _Universe__lookupQuestionRti(universe, baseType, normalize) {
        var t1,
          key = baseType._canonicalRecipe + "?",
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        t1 = A._Universe__createQuestionRti(universe, baseType, key, normalize);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__createQuestionRti(universe, baseType, key, normalize) {
        var baseKind, t1, starArgument, rti;
        if (normalize) {
          baseKind = baseType._kind;
          if (!A.isSoundTopType(baseType))
            if (!(baseType === type$.Null || baseType === type$.JSNull))
              if (baseKind !== 7)
                t1 = baseKind === 8 && A.isNullable(baseType._primary);
              else
                t1 = true;
            else
              t1 = true;
          else
            t1 = true;
          if (t1)
            return baseType;
          else if (baseKind === 1 || baseType === type$.legacy_Never)
            return type$.Null;
          else if (baseKind === 6) {
            starArgument = baseType._primary;
            if (starArgument._kind === 8 && A.isNullable(starArgument._primary))
              return starArgument;
            else
              return A.Rti__getQuestionFromStar(universe, baseType);
          }
        }
        rti = new A.Rti(null, null);
        rti._kind = 7;
        rti._primary = baseType;
        rti._canonicalRecipe = key;
        return A._Universe__installTypeTests(universe, rti);
      },
      _Universe__lookupFutureOrRti(universe, baseType, normalize) {
        var t1,
          key = baseType._canonicalRecipe + "/",
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        t1 = A._Universe__createFutureOrRti(universe, baseType, key, normalize);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__createFutureOrRti(universe, baseType, key, normalize) {
        var t1, rti;
        if (normalize) {
          t1 = baseType._kind;
          if (A.isSoundTopType(baseType) || baseType === type$.Object || baseType === type$.legacy_Object)
            return baseType;
          else if (t1 === 1)
            return A._Universe__lookupInterfaceRti(universe, "Future", [baseType]);
          else if (baseType === type$.Null || baseType === type$.JSNull)
            return type$.nullable_Future_Null;
        }
        rti = new A.Rti(null, null);
        rti._kind = 8;
        rti._primary = baseType;
        rti._canonicalRecipe = key;
        return A._Universe__installTypeTests(universe, rti);
      },
      _Universe__lookupGenericFunctionParameterRti(universe, index) {
        var rti, t1,
          key = "" + index + "^",
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = 14;
        rti._primary = index;
        rti._canonicalRecipe = key;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__canonicalRecipeJoin($arguments) {
        var s, sep, i,
          $length = $arguments.length;
        for (s = "", sep = "", i = 0; i < $length; ++i, sep = ",")
          s += sep + $arguments[i]._canonicalRecipe;
        return s;
      },
      _Universe__canonicalRecipeJoinNamed($arguments) {
        var s, sep, i, t1, nameSep,
          $length = $arguments.length;
        for (s = "", sep = "", i = 0; i < $length; i += 3, sep = ",") {
          t1 = $arguments[i];
          nameSep = $arguments[i + 1] ? "!" : ":";
          s += sep + t1 + nameSep + $arguments[i + 2]._canonicalRecipe;
        }
        return s;
      },
      _Universe__lookupInterfaceRti(universe, $name, $arguments) {
        var probe, rti, t1,
          s = $name;
        if ($arguments.length > 0)
          s += "<" + A._Universe__canonicalRecipeJoin($arguments) + ">";
        probe = universe.eC.get(s);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = 9;
        rti._primary = $name;
        rti._rest = $arguments;
        if ($arguments.length > 0)
          rti._precomputed1 = $arguments[0];
        rti._canonicalRecipe = s;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(s, t1);
        return t1;
      },
      _Universe__lookupBindingRti(universe, base, $arguments) {
        var newBase, newArguments, key, probe, rti, t1;
        if (base._kind === 10) {
          newBase = base._primary;
          newArguments = base._rest.concat($arguments);
        } else {
          newArguments = $arguments;
          newBase = base;
        }
        key = newBase._canonicalRecipe + (";<" + A._Universe__canonicalRecipeJoin(newArguments) + ">");
        probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = 10;
        rti._primary = newBase;
        rti._rest = newArguments;
        rti._canonicalRecipe = key;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__lookupRecordRti(universe, partialShapeTag, fields) {
        var rti, t1,
          key = "+" + (partialShapeTag + "(" + A._Universe__canonicalRecipeJoin(fields) + ")"),
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = 11;
        rti._primary = partialShapeTag;
        rti._rest = fields;
        rti._canonicalRecipe = key;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__lookupFunctionRti(universe, returnType, parameters) {
        var sep, key, probe, rti, t1,
          s = returnType._canonicalRecipe,
          requiredPositional = parameters._requiredPositional,
          requiredPositionalLength = requiredPositional.length,
          optionalPositional = parameters._optionalPositional,
          optionalPositionalLength = optionalPositional.length,
          named = parameters._named,
          namedLength = named.length,
          recipe = "(" + A._Universe__canonicalRecipeJoin(requiredPositional);
        if (optionalPositionalLength > 0) {
          sep = requiredPositionalLength > 0 ? "," : "";
          recipe += sep + "[" + A._Universe__canonicalRecipeJoin(optionalPositional) + "]";
        }
        if (namedLength > 0) {
          sep = requiredPositionalLength > 0 ? "," : "";
          recipe += sep + "{" + A._Universe__canonicalRecipeJoinNamed(named) + "}";
        }
        key = s + (recipe + ")");
        probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        rti = new A.Rti(null, null);
        rti._kind = 12;
        rti._primary = returnType;
        rti._rest = parameters;
        rti._canonicalRecipe = key;
        t1 = A._Universe__installTypeTests(universe, rti);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__lookupGenericFunctionRti(universe, baseFunctionType, bounds, normalize) {
        var t1,
          key = baseFunctionType._canonicalRecipe + ("<" + A._Universe__canonicalRecipeJoin(bounds) + ">"),
          probe = universe.eC.get(key);
        if (probe != null)
          return probe;
        t1 = A._Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize);
        universe.eC.set(key, t1);
        return t1;
      },
      _Universe__createGenericFunctionRti(universe, baseFunctionType, bounds, key, normalize) {
        var $length, typeArguments, count, i, bound, substitutedBase, substitutedBounds, rti;
        if (normalize) {
          $length = bounds.length;
          typeArguments = A._Utils_newArrayOrEmpty($length);
          for (count = 0, i = 0; i < $length; ++i) {
            bound = bounds[i];
            if (bound._kind === 1) {
              typeArguments[i] = bound;
              ++count;
            }
          }
          if (count > 0) {
            substitutedBase = A._substitute(universe, baseFunctionType, typeArguments, 0);
            substitutedBounds = A._substituteArray(universe, bounds, typeArguments, 0);
            return A._Universe__lookupGenericFunctionRti(universe, substitutedBase, substitutedBounds, bounds !== substitutedBounds);
          }
        }
        rti = new A.Rti(null, null);
        rti._kind = 13;
        rti._primary = baseFunctionType;
        rti._rest = bounds;
        rti._canonicalRecipe = key;
        return A._Universe__installTypeTests(universe, rti);
      },
      _Parser_create(universe, environment, recipe, normalize) {
        return { u: universe, e: environment, r: recipe, s: [], p: 0, n: normalize };
      },
      _Parser_parse(parser) {
        var t2, i, ch, t3, array, end, item,
          source = parser.r,
          t1 = parser.s;
        for (t2 = source.length, i = 0; i < t2;) {
          ch = source.charCodeAt(i);
          if (ch >= 48 && ch <= 57)
            i = A._Parser_handleDigit(i + 1, ch, source, t1);
          else if ((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124)
            i = A._Parser_handleIdentifier(parser, i, source, t1, false);
          else if (ch === 46)
            i = A._Parser_handleIdentifier(parser, i, source, t1, true);
          else {
            ++i;
            switch (ch) {
              case 44:
                break;
              case 58:
                t1.push(false);
                break;
              case 33:
                t1.push(true);
                break;
              case 59:
                t1.push(A._Parser_toType(parser.u, parser.e, t1.pop()));
                break;
              case 94:
                t1.push(A._Universe__lookupGenericFunctionParameterRti(parser.u, t1.pop()));
                break;
              case 35:
                t1.push(A._Universe__lookupTerminalRti(parser.u, 5, "#"));
                break;
              case 64:
                t1.push(A._Universe__lookupTerminalRti(parser.u, 2, "@"));
                break;
              case 126:
                t1.push(A._Universe__lookupTerminalRti(parser.u, 3, "~"));
                break;
              case 60:
                t1.push(parser.p);
                parser.p = t1.length;
                break;
              case 62:
                A._Parser_handleTypeArguments(parser, t1);
                break;
              case 38:
                A._Parser_handleExtendedOperations(parser, t1);
                break;
              case 42:
                t3 = parser.u;
                t1.push(A._Universe__lookupStarRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
                break;
              case 63:
                t3 = parser.u;
                t1.push(A._Universe__lookupQuestionRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
                break;
              case 47:
                t3 = parser.u;
                t1.push(A._Universe__lookupFutureOrRti(t3, A._Parser_toType(t3, parser.e, t1.pop()), parser.n));
                break;
              case 40:
                t1.push(-3);
                t1.push(parser.p);
                parser.p = t1.length;
                break;
              case 41:
                A._Parser_handleArguments(parser, t1);
                break;
              case 91:
                t1.push(parser.p);
                parser.p = t1.length;
                break;
              case 93:
                array = t1.splice(parser.p);
                A._Parser_toTypes(parser.u, parser.e, array);
                parser.p = t1.pop();
                t1.push(array);
                t1.push(-1);
                break;
              case 123:
                t1.push(parser.p);
                parser.p = t1.length;
                break;
              case 125:
                array = t1.splice(parser.p);
                A._Parser_toTypesNamed(parser.u, parser.e, array);
                parser.p = t1.pop();
                t1.push(array);
                t1.push(-2);
                break;
              case 43:
                end = source.indexOf("(", i);
                t1.push(source.substring(i, end));
                t1.push(-4);
                t1.push(parser.p);
                parser.p = t1.length;
                i = end + 1;
                break;
              default:
                throw "Bad character " + ch;
            }
          }
        }
        item = t1.pop();
        return A._Parser_toType(parser.u, parser.e, item);
      },
      _Parser_handleDigit(i, digit, source, stack) {
        var t1, ch,
          value = digit - 48;
        for (t1 = source.length; i < t1; ++i) {
          ch = source.charCodeAt(i);
          if (!(ch >= 48 && ch <= 57))
            break;
          value = value * 10 + (ch - 48);
        }
        stack.push(value);
        return i;
      },
      _Parser_handleIdentifier(parser, start, source, stack, hasPeriod) {
        var t1, ch, t2, string, environment, recipe,
          i = start + 1;
        for (t1 = source.length; i < t1; ++i) {
          ch = source.charCodeAt(i);
          if (ch === 46) {
            if (hasPeriod)
              break;
            hasPeriod = true;
          } else {
            if (!((((ch | 32) >>> 0) - 97 & 65535) < 26 || ch === 95 || ch === 36 || ch === 124))
              t2 = ch >= 48 && ch <= 57;
            else
              t2 = true;
            if (!t2)
              break;
          }
        }
        string = source.substring(start, i);
        if (hasPeriod) {
          t1 = parser.u;
          environment = parser.e;
          if (environment._kind === 10)
            environment = environment._primary;
          recipe = A._Universe_findRule(t1, environment._primary)[string];
          if (recipe == null)
            A.throwExpression('No "' + string + '" in "' + A.Rti__getCanonicalRecipe(environment) + '"');
          stack.push(A._Universe_evalInEnvironment(t1, environment, recipe));
        } else
          stack.push(string);
        return i;
      },
      _Parser_handleTypeArguments(parser, stack) {
        var base,
          t1 = parser.u,
          $arguments = A._Parser_collectArray(parser, stack),
          head = stack.pop();
        if (typeof head == "string")
          stack.push(A._Universe__lookupInterfaceRti(t1, head, $arguments));
        else {
          base = A._Parser_toType(t1, parser.e, head);
          switch (base._kind) {
            case 12:
              stack.push(A._Universe__lookupGenericFunctionRti(t1, base, $arguments, parser.n));
              break;
            default:
              stack.push(A._Universe__lookupBindingRti(t1, base, $arguments));
              break;
          }
        }
      },
      _Parser_handleArguments(parser, stack) {
        var optionalPositional, named, requiredPositional, returnType, parameters, _null = null,
          t1 = parser.u,
          head = stack.pop();
        if (typeof head == "number")
          switch (head) {
            case -1:
              optionalPositional = stack.pop();
              named = _null;
              break;
            case -2:
              named = stack.pop();
              optionalPositional = _null;
              break;
            default:
              stack.push(head);
              named = _null;
              optionalPositional = named;
              break;
          }
        else {
          stack.push(head);
          named = _null;
          optionalPositional = named;
        }
        requiredPositional = A._Parser_collectArray(parser, stack);
        head = stack.pop();
        switch (head) {
          case -3:
            head = stack.pop();
            if (optionalPositional == null)
              optionalPositional = t1.sEA;
            if (named == null)
              named = t1.sEA;
            returnType = A._Parser_toType(t1, parser.e, head);
            parameters = new A._FunctionParameters();
            parameters._requiredPositional = requiredPositional;
            parameters._optionalPositional = optionalPositional;
            parameters._named = named;
            stack.push(A._Universe__lookupFunctionRti(t1, returnType, parameters));
            return;
          case -4:
            stack.push(A._Universe__lookupRecordRti(t1, stack.pop(), requiredPositional));
            return;
          default:
            throw A.wrapException(A.AssertionError$("Unexpected state under `()`: " + A.S(head)));
        }
      },
      _Parser_handleExtendedOperations(parser, stack) {
        var $top = stack.pop();
        if (0 === $top) {
          stack.push(A._Universe__lookupTerminalRti(parser.u, 1, "0&"));
          return;
        }
        if (1 === $top) {
          stack.push(A._Universe__lookupTerminalRti(parser.u, 4, "1&"));
          return;
        }
        throw A.wrapException(A.AssertionError$("Unexpected extended operation " + A.S($top)));
      },
      _Parser_collectArray(parser, stack) {
        var array = stack.splice(parser.p);
        A._Parser_toTypes(parser.u, parser.e, array);
        parser.p = stack.pop();
        return array;
      },
      _Parser_toType(universe, environment, item) {
        if (typeof item == "string")
          return A._Universe__lookupInterfaceRti(universe, item, universe.sEA);
        else if (typeof item == "number") {
          environment.toString;
          return A._Parser_indexToType(universe, environment, item);
        } else
          return item;
      },
      _Parser_toTypes(universe, environment, items) {
        var i,
          $length = items.length;
        for (i = 0; i < $length; ++i)
          items[i] = A._Parser_toType(universe, environment, items[i]);
      },
      _Parser_toTypesNamed(universe, environment, items) {
        var i,
          $length = items.length;
        for (i = 2; i < $length; i += 3)
          items[i] = A._Parser_toType(universe, environment, items[i]);
      },
      _Parser_indexToType(universe, environment, index) {
        var typeArguments, len,
          kind = environment._kind;
        if (kind === 10) {
          if (index === 0)
            return environment._primary;
          typeArguments = environment._rest;
          len = typeArguments.length;
          if (index <= len)
            return typeArguments[index - 1];
          index -= len;
          environment = environment._primary;
          kind = environment._kind;
        } else if (index === 0)
          return environment;
        if (kind !== 9)
          throw A.wrapException(A.AssertionError$("Indexed base must be an interface type"));
        typeArguments = environment._rest;
        if (index <= typeArguments.length)
          return typeArguments[index - 1];
        throw A.wrapException(A.AssertionError$("Bad index " + index + " for " + environment.toString$0(0)));
      },
      isSubtype(universe, s, t) {
        var result,
          sCache = s._isSubtypeCache;
        if (sCache == null)
          sCache = s._isSubtypeCache = new Map();
        result = sCache.get(t);
        if (result == null) {
          result = A._isSubtype(universe, s, null, t, null, false) ? 1 : 0;
          sCache.set(t, result);
        }
        if (0 === result)
          return false;
        if (1 === result)
          return true;
        return true;
      },
      _isSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
        var t1, sKind, leftTypeVariable, tKind, t2, sBounds, tBounds, sLength, i, sBound, tBound;
        if (s === t)
          return true;
        if (!A.isSoundTopType(t))
          if (!(t === type$.legacy_Object))
            t1 = false;
          else
            t1 = true;
        else
          t1 = true;
        if (t1)
          return true;
        sKind = s._kind;
        if (sKind === 4)
          return true;
        if (A.isSoundTopType(s))
          return false;
        if (s._kind !== 1)
          t1 = false;
        else
          t1 = true;
        if (t1)
          return true;
        leftTypeVariable = sKind === 14;
        if (leftTypeVariable)
          if (A._isSubtype(universe, sEnv[s._primary], sEnv, t, tEnv, false))
            return true;
        tKind = t._kind;
        t1 = s === type$.Null || s === type$.JSNull;
        if (t1) {
          if (tKind === 8)
            return A._isSubtype(universe, s, sEnv, t._primary, tEnv, false);
          return t === type$.Null || t === type$.JSNull || tKind === 7 || tKind === 6;
        }
        if (t === type$.Object) {
          if (sKind === 8)
            return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
          if (sKind === 6)
            return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
          return sKind !== 7;
        }
        if (sKind === 6)
          return A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
        if (tKind === 6) {
          t1 = A.Rti__getQuestionFromStar(universe, t);
          return A._isSubtype(universe, s, sEnv, t1, tEnv, false);
        }
        if (sKind === 8) {
          if (!A._isSubtype(universe, s._primary, sEnv, t, tEnv, false))
            return false;
          return A._isSubtype(universe, A.Rti__getFutureFromFutureOr(universe, s), sEnv, t, tEnv, false);
        }
        if (sKind === 7) {
          t1 = A._isSubtype(universe, type$.Null, sEnv, t, tEnv, false);
          return t1 && A._isSubtype(universe, s._primary, sEnv, t, tEnv, false);
        }
        if (tKind === 8) {
          if (A._isSubtype(universe, s, sEnv, t._primary, tEnv, false))
            return true;
          return A._isSubtype(universe, s, sEnv, A.Rti__getFutureFromFutureOr(universe, t), tEnv, false);
        }
        if (tKind === 7) {
          t1 = A._isSubtype(universe, s, sEnv, type$.Null, tEnv, false);
          return t1 || A._isSubtype(universe, s, sEnv, t._primary, tEnv, false);
        }
        if (leftTypeVariable)
          return false;
        t1 = sKind !== 12;
        if ((!t1 || sKind === 13) && t === type$.Function)
          return true;
        t2 = sKind === 11;
        if (t2 && t === type$.Record)
          return true;
        if (tKind === 13) {
          if (s === type$.JavaScriptFunction)
            return true;
          if (sKind !== 13)
            return false;
          sBounds = s._rest;
          tBounds = t._rest;
          sLength = sBounds.length;
          if (sLength !== tBounds.length)
            return false;
          sEnv = sEnv == null ? sBounds : sBounds.concat(sEnv);
          tEnv = tEnv == null ? tBounds : tBounds.concat(tEnv);
          for (i = 0; i < sLength; ++i) {
            sBound = sBounds[i];
            tBound = tBounds[i];
            if (!A._isSubtype(universe, sBound, sEnv, tBound, tEnv, false) || !A._isSubtype(universe, tBound, tEnv, sBound, sEnv, false))
              return false;
          }
          return A._isFunctionSubtype(universe, s._primary, sEnv, t._primary, tEnv, false);
        }
        if (tKind === 12) {
          if (s === type$.JavaScriptFunction)
            return true;
          if (t1)
            return false;
          return A._isFunctionSubtype(universe, s, sEnv, t, tEnv, false);
        }
        if (sKind === 9) {
          if (tKind !== 9)
            return false;
          return A._isInterfaceSubtype(universe, s, sEnv, t, tEnv, false);
        }
        if (t2 && tKind === 11)
          return A._isRecordSubtype(universe, s, sEnv, t, tEnv, false);
        return false;
      },
      _isFunctionSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
        var sParameters, tParameters, sRequiredPositional, tRequiredPositional, sRequiredPositionalLength, tRequiredPositionalLength, requiredPositionalDelta, sOptionalPositional, tOptionalPositional, sOptionalPositionalLength, tOptionalPositionalLength, i, t1, sNamed, tNamed, sNamedLength, tNamedLength, sIndex, tIndex, tName, sName, sIsRequired;
        if (!A._isSubtype(universe, s._primary, sEnv, t._primary, tEnv, false))
          return false;
        sParameters = s._rest;
        tParameters = t._rest;
        sRequiredPositional = sParameters._requiredPositional;
        tRequiredPositional = tParameters._requiredPositional;
        sRequiredPositionalLength = sRequiredPositional.length;
        tRequiredPositionalLength = tRequiredPositional.length;
        if (sRequiredPositionalLength > tRequiredPositionalLength)
          return false;
        requiredPositionalDelta = tRequiredPositionalLength - sRequiredPositionalLength;
        sOptionalPositional = sParameters._optionalPositional;
        tOptionalPositional = tParameters._optionalPositional;
        sOptionalPositionalLength = sOptionalPositional.length;
        tOptionalPositionalLength = tOptionalPositional.length;
        if (sRequiredPositionalLength + sOptionalPositionalLength < tRequiredPositionalLength + tOptionalPositionalLength)
          return false;
        for (i = 0; i < sRequiredPositionalLength; ++i) {
          t1 = sRequiredPositional[i];
          if (!A._isSubtype(universe, tRequiredPositional[i], tEnv, t1, sEnv, false))
            return false;
        }
        for (i = 0; i < requiredPositionalDelta; ++i) {
          t1 = sOptionalPositional[i];
          if (!A._isSubtype(universe, tRequiredPositional[sRequiredPositionalLength + i], tEnv, t1, sEnv, false))
            return false;
        }
        for (i = 0; i < tOptionalPositionalLength; ++i) {
          t1 = sOptionalPositional[requiredPositionalDelta + i];
          if (!A._isSubtype(universe, tOptionalPositional[i], tEnv, t1, sEnv, false))
            return false;
        }
        sNamed = sParameters._named;
        tNamed = tParameters._named;
        sNamedLength = sNamed.length;
        tNamedLength = tNamed.length;
        for (sIndex = 0, tIndex = 0; tIndex < tNamedLength; tIndex += 3) {
          tName = tNamed[tIndex];
          for (; true;) {
            if (sIndex >= sNamedLength)
              return false;
            sName = sNamed[sIndex];
            sIndex += 3;
            if (tName < sName)
              return false;
            sIsRequired = sNamed[sIndex - 2];
            if (sName < tName) {
              if (sIsRequired)
                return false;
              continue;
            }
            t1 = tNamed[tIndex + 1];
            if (sIsRequired && !t1)
              return false;
            t1 = sNamed[sIndex - 1];
            if (!A._isSubtype(universe, tNamed[tIndex + 2], tEnv, t1, sEnv, false))
              return false;
            break;
          }
        }
        for (; sIndex < sNamedLength;) {
          if (sNamed[sIndex + 1])
            return false;
          sIndex += 3;
        }
        return true;
      },
      _isInterfaceSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
        var rule, recipes, $length, supertypeArgs, i,
          sName = s._primary,
          tName = t._primary;
        for (; sName !== tName;) {
          rule = universe.tR[sName];
          if (rule == null)
            return false;
          if (typeof rule == "string") {
            sName = rule;
            continue;
          }
          recipes = rule[tName];
          if (recipes == null)
            return false;
          $length = recipes.length;
          supertypeArgs = $length > 0 ? new Array($length) : init.typeUniverse.sEA;
          for (i = 0; i < $length; ++i)
            supertypeArgs[i] = A._Universe_evalInEnvironment(universe, s, recipes[i]);
          return A._areArgumentsSubtypes(universe, supertypeArgs, null, sEnv, t._rest, tEnv, false);
        }
        return A._areArgumentsSubtypes(universe, s._rest, null, sEnv, t._rest, tEnv, false);
      },
      _areArgumentsSubtypes(universe, sArgs, sVariances, sEnv, tArgs, tEnv, isLegacy) {
        var i,
          $length = sArgs.length;
        for (i = 0; i < $length; ++i)
          if (!A._isSubtype(universe, sArgs[i], sEnv, tArgs[i], tEnv, false))
            return false;
        return true;
      },
      _isRecordSubtype(universe, s, sEnv, t, tEnv, isLegacy) {
        var i,
          sFields = s._rest,
          tFields = t._rest,
          sCount = sFields.length;
        if (sCount !== tFields.length)
          return false;
        if (s._primary !== t._primary)
          return false;
        for (i = 0; i < sCount; ++i)
          if (!A._isSubtype(universe, sFields[i], sEnv, tFields[i], tEnv, false))
            return false;
        return true;
      },
      isNullable(t) {
        var t1,
          kind = t._kind;
        if (!(t === type$.Null || t === type$.JSNull))
          if (!A.isSoundTopType(t))
            if (kind !== 7)
              if (!(kind === 6 && A.isNullable(t._primary)))
                t1 = kind === 8 && A.isNullable(t._primary);
              else
                t1 = true;
            else
              t1 = true;
          else
            t1 = true;
        else
          t1 = true;
        return t1;
      },
      isDefinitelyTopType(t) {
        var t1;
        if (!A.isSoundTopType(t))
          if (!(t === type$.legacy_Object))
            t1 = false;
          else
            t1 = true;
        else
          t1 = true;
        return t1;
      },
      isSoundTopType(t) {
        var kind = t._kind;
        return kind === 2 || kind === 3 || kind === 4 || kind === 5 || t === type$.nullable_Object;
      },
      _Utils_objectAssign(o, other) {
        var i, key,
          keys = Object.keys(other),
          $length = keys.length;
        for (i = 0; i < $length; ++i) {
          key = keys[i];
          o[key] = other[key];
        }
      },
      _Utils_newArrayOrEmpty($length) {
        return $length > 0 ? new Array($length) : init.typeUniverse.sEA;
      },
      Rti: function Rti(t0, t1) {
        var _ = this;
        _._as = t0;
        _._is = t1;
        _._cachedRuntimeType = _._specializedTestResource = _._isSubtypeCache = _._precomputed1 = null;
        _._kind = 0;
        _._canonicalRecipe = _._bindCache = _._evalCache = _._rest = _._primary = null;
      },
      _FunctionParameters: function _FunctionParameters() {
        this._named = this._optionalPositional = this._requiredPositional = null;
      },
      _Type: function _Type(t0) {
        this._rti = t0;
      },
      _Error: function _Error() {
      },
      _TypeError: function _TypeError(t0) {
        this.__rti$_message = t0;
      },
      _AsyncRun__initializeScheduleImmediate() {
        var div, span, t1 = {};
        if (self.scheduleImmediate != null)
          return A.async__AsyncRun__scheduleImmediateJsOverride$closure();
        if (self.MutationObserver != null && self.document != null) {
          div = self.document.createElement("div");
          span = self.document.createElement("span");
          t1.storedCallback = null;
          new self.MutationObserver(A.convertDartClosureToJS(new A._AsyncRun__initializeScheduleImmediate_internalCallback(t1), 1)).observe(div, { childList: true });
          return new A._AsyncRun__initializeScheduleImmediate_closure(t1, div, span);
        } else if (self.setImmediate != null)
          return A.async__AsyncRun__scheduleImmediateWithSetImmediate$closure();
        return A.async__AsyncRun__scheduleImmediateWithTimer$closure();
      },
      _AsyncRun__scheduleImmediateJsOverride(callback) {
        self.scheduleImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateJsOverride_internalCallback(type$.void_Function._as(callback)), 0));
      },
      _AsyncRun__scheduleImmediateWithSetImmediate(callback) {
        self.setImmediate(A.convertDartClosureToJS(new A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(type$.void_Function._as(callback)), 0));
      },
      _AsyncRun__scheduleImmediateWithTimer(callback) {
        A.Timer__createTimer(B.Duration_0, type$.void_Function._as(callback));
      },
      Timer__createTimer(duration, callback) {
        var milliseconds = B.JSInt_methods._tdivFast$1(duration._duration, 1000);
        return A._TimerImpl$(milliseconds, callback);
      },
      _TimerImpl$(milliseconds, callback) {
        var t1 = new A._TimerImpl();
        t1._TimerImpl$2(milliseconds, callback);
        return t1;
      },
      AsyncError$(error, stackTrace) {
        var t1 = A.checkNotNullable(error, "error", type$.Object);
        return new A.AsyncError(t1, stackTrace == null ? A.AsyncError_defaultStackTrace(error) : stackTrace);
      },
      AsyncError_defaultStackTrace(error) {
        var stackTrace;
        if (type$.Error._is(error)) {
          stackTrace = error.get$stackTrace();
          if (stackTrace != null)
            return stackTrace;
        }
        return B.C__StringStackTrace;
      },
      Future_Future$delayed(duration, $T) {
        var result,
          t1 = !$T._is(null);
        if (t1)
          throw A.wrapException(A.ArgumentError$value(null, "computation", "The type parameter is not nullable"));
        result = new A._Future($.Zone__current, $T._eval$1("_Future<0>"));
        A.Timer_Timer(duration, new A.Future_Future$delayed_closure(null, result, $T));
        return result;
      },
      _Future__chainCoreFutureSync(source, target) {
        var t1, t2, listeners;
        for (t1 = type$._Future_dynamic; t2 = source._state, (t2 & 4) !== 0;)
          source = t1._as(source._resultOrListeners);
        if ((t2 & 24) !== 0) {
          listeners = target._removeListeners$0();
          target._cloneResult$1(source);
          A._Future__propagateToListeners(target, listeners);
        } else {
          listeners = type$.nullable__FutureListener_dynamic_dynamic._as(target._resultOrListeners);
          target._state = target._state & 1 | 4;
          target._resultOrListeners = source;
          source._prependListeners$1(listeners);
        }
      },
      _Future__propagateToListeners(source, listeners) {
        var t2, t3, t4, _box_0, t5, t6, hasError, asyncError, nextListener, nextListener0, sourceResult, t7, zone, oldZone, result, current, _box_1 = {},
          t1 = _box_1.source = source;
        for (t2 = type$.AsyncError, t3 = type$.nullable__FutureListener_dynamic_dynamic, t4 = type$.Future_dynamic; true;) {
          _box_0 = {};
          t5 = t1._state;
          t6 = (t5 & 16) === 0;
          hasError = !t6;
          if (listeners == null) {
            if (hasError && (t5 & 1) === 0) {
              asyncError = t2._as(t1._resultOrListeners);
              A._rootHandleError(asyncError.error, asyncError.stackTrace);
            }
            return;
          }
          _box_0.listener = listeners;
          nextListener = listeners._nextListener;
          for (t1 = listeners; nextListener != null; t1 = nextListener, nextListener = nextListener0) {
            t1._nextListener = null;
            A._Future__propagateToListeners(_box_1.source, t1);
            _box_0.listener = nextListener;
            nextListener0 = nextListener._nextListener;
          }
          t5 = _box_1.source;
          sourceResult = t5._resultOrListeners;
          _box_0.listenerHasError = hasError;
          _box_0.listenerValueOrError = sourceResult;
          if (t6) {
            t7 = t1.state;
            t7 = (t7 & 1) !== 0 || (t7 & 15) === 8;
          } else
            t7 = true;
          if (t7) {
            zone = t1.result._zone;
            if (hasError) {
              t5 = t5._zone === zone;
              t5 = !(t5 || t5);
            } else
              t5 = false;
            if (t5) {
              t2._as(sourceResult);
              A._rootHandleError(sourceResult.error, sourceResult.stackTrace);
              return;
            }
            oldZone = $.Zone__current;
            if (oldZone !== zone)
              $.Zone__current = zone;
            else
              oldZone = null;
            t1 = t1.state;
            if ((t1 & 15) === 8)
              new A._Future__propagateToListeners_handleWhenCompleteCallback(_box_0, _box_1, hasError).call$0();
            else if (t6) {
              if ((t1 & 1) !== 0)
                new A._Future__propagateToListeners_handleValueCallback(_box_0, sourceResult).call$0();
            } else if ((t1 & 2) !== 0)
              new A._Future__propagateToListeners_handleError(_box_1, _box_0).call$0();
            if (oldZone != null)
              $.Zone__current = oldZone;
            t1 = _box_0.listenerValueOrError;
            if (t1 instanceof A._Future) {
              t5 = _box_0.listener.$ti;
              t5 = t5._eval$1("Future<2>")._is(t1) || !t5._rest[1]._is(t1);
            } else
              t5 = false;
            if (t5) {
              t4._as(t1);
              result = _box_0.listener.result;
              if ((t1._state & 24) !== 0) {
                current = t3._as(result._resultOrListeners);
                result._resultOrListeners = null;
                listeners = result._reverseListeners$1(current);
                result._state = t1._state & 30 | result._state & 1;
                result._resultOrListeners = t1._resultOrListeners;
                _box_1.source = t1;
                continue;
              } else
                A._Future__chainCoreFutureSync(t1, result);
              return;
            }
          }
          result = _box_0.listener.result;
          current = t3._as(result._resultOrListeners);
          result._resultOrListeners = null;
          listeners = result._reverseListeners$1(current);
          t1 = _box_0.listenerHasError;
          t5 = _box_0.listenerValueOrError;
          if (!t1) {
            result.$ti._precomputed1._as(t5);
            result._state = 8;
            result._resultOrListeners = t5;
          } else {
            t2._as(t5);
            result._state = result._state & 1 | 16;
            result._resultOrListeners = t5;
          }
          _box_1.source = result;
          t1 = result;
        }
      },
      _registerErrorHandler(errorHandler, zone) {
        var t1 = type$.dynamic_Function_Object_StackTrace;
        if (t1._is(errorHandler))
          return t1._as(errorHandler);
        t1 = type$.dynamic_Function_Object;
        if (t1._is(errorHandler))
          return t1._as(errorHandler);
        throw A.wrapException(A.ArgumentError$value(errorHandler, "onError", string$.Error_));
      },
      _microtaskLoop() {
        var entry, next;
        for (entry = $._nextCallback; entry != null; entry = $._nextCallback) {
          $._lastPriorityCallback = null;
          next = entry.next;
          $._nextCallback = next;
          if (next == null)
            $._lastCallback = null;
          entry.callback.call$0();
        }
      },
      _startMicrotaskLoop() {
        $._isInCallbackLoop = true;
        try {
          A._microtaskLoop();
        } finally {
          $._lastPriorityCallback = null;
          $._isInCallbackLoop = false;
          if ($._nextCallback != null)
            $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure());
        }
      },
      _scheduleAsyncCallback(callback) {
        var newEntry = new A._AsyncCallbackEntry(callback),
          lastCallback = $._lastCallback;
        if (lastCallback == null) {
          $._nextCallback = $._lastCallback = newEntry;
          if (!$._isInCallbackLoop)
            $.$get$_AsyncRun__scheduleImmediateClosure().call$1(A.async___startMicrotaskLoop$closure());
        } else
          $._lastCallback = lastCallback.next = newEntry;
      },
      _schedulePriorityAsyncCallback(callback) {
        var entry, lastPriorityCallback, next,
          t1 = $._nextCallback;
        if (t1 == null) {
          A._scheduleAsyncCallback(callback);
          $._lastPriorityCallback = $._lastCallback;
          return;
        }
        entry = new A._AsyncCallbackEntry(callback);
        lastPriorityCallback = $._lastPriorityCallback;
        if (lastPriorityCallback == null) {
          entry.next = t1;
          $._nextCallback = $._lastPriorityCallback = entry;
        } else {
          next = lastPriorityCallback.next;
          entry.next = next;
          $._lastPriorityCallback = lastPriorityCallback.next = entry;
          if (next == null)
            $._lastCallback = entry;
        }
      },
      scheduleMicrotask(callback) {
        var t1, _null = null,
          currentZone = $.Zone__current;
        if (B.C__RootZone === currentZone) {
          A._rootScheduleMicrotask(_null, _null, B.C__RootZone, callback);
          return;
        }
        t1 = false;
        if (t1) {
          A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(callback));
          return;
        }
        A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(currentZone.bindCallbackGuarded$1(callback)));
      },
      Timer_Timer(duration, callback) {
        var t1 = $.Zone__current;
        if (t1 === B.C__RootZone)
          return A.Timer__createTimer(duration, type$.void_Function._as(callback));
        return A.Timer__createTimer(duration, type$.void_Function._as(t1.bindCallbackGuarded$1(callback)));
      },
      _rootHandleError(error, stackTrace) {
        A._schedulePriorityAsyncCallback(new A._rootHandleError_closure(error, stackTrace));
      },
      _rootRun($self, $parent, zone, f, $R) {
        var old,
          t1 = $.Zone__current;
        if (t1 === zone)
          return f.call$0();
        $.Zone__current = zone;
        old = t1;
        try {
          t1 = f.call$0();
          return t1;
        } finally {
          $.Zone__current = old;
        }
      },
      _rootRunUnary($self, $parent, zone, f, arg, $R, $T) {
        var old,
          t1 = $.Zone__current;
        if (t1 === zone)
          return f.call$1(arg);
        $.Zone__current = zone;
        old = t1;
        try {
          t1 = f.call$1(arg);
          return t1;
        } finally {
          $.Zone__current = old;
        }
      },
      _rootRunBinary($self, $parent, zone, f, arg1, arg2, $R, T1, T2) {
        var old,
          t1 = $.Zone__current;
        if (t1 === zone)
          return f.call$2(arg1, arg2);
        $.Zone__current = zone;
        old = t1;
        try {
          t1 = f.call$2(arg1, arg2);
          return t1;
        } finally {
          $.Zone__current = old;
        }
      },
      _rootScheduleMicrotask($self, $parent, zone, f) {
        type$.void_Function._as(f);
        if (B.C__RootZone !== zone)
          f = zone.bindCallbackGuarded$1(f);
        A._scheduleAsyncCallback(f);
      },
      _AsyncRun__initializeScheduleImmediate_internalCallback: function _AsyncRun__initializeScheduleImmediate_internalCallback(t0) {
        this._box_0 = t0;
      },
      _AsyncRun__initializeScheduleImmediate_closure: function _AsyncRun__initializeScheduleImmediate_closure(t0, t1, t2) {
        this._box_0 = t0;
        this.div = t1;
        this.span = t2;
      },
      _AsyncRun__scheduleImmediateJsOverride_internalCallback: function _AsyncRun__scheduleImmediateJsOverride_internalCallback(t0) {
        this.callback = t0;
      },
      _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback: function _AsyncRun__scheduleImmediateWithSetImmediate_internalCallback(t0) {
        this.callback = t0;
      },
      _TimerImpl: function _TimerImpl() {
      },
      _TimerImpl_internalCallback: function _TimerImpl_internalCallback(t0, t1) {
        this.$this = t0;
        this.callback = t1;
      },
      AsyncError: function AsyncError(t0, t1) {
        this.error = t0;
        this.stackTrace = t1;
      },
      Future_Future$delayed_closure: function Future_Future$delayed_closure(t0, t1, t2) {
        this.computation = t0;
        this.result = t1;
        this.T = t2;
      },
      _FutureListener: function _FutureListener(t0, t1, t2, t3, t4) {
        var _ = this;
        _._nextListener = null;
        _.result = t0;
        _.state = t1;
        _.callback = t2;
        _.errorCallback = t3;
        _.$ti = t4;
      },
      _Future: function _Future(t0, t1) {
        var _ = this;
        _._state = 0;
        _._zone = t0;
        _._resultOrListeners = null;
        _.$ti = t1;
      },
      _Future__addListener_closure: function _Future__addListener_closure(t0, t1) {
        this.$this = t0;
        this.listener = t1;
      },
      _Future__prependListeners_closure: function _Future__prependListeners_closure(t0, t1) {
        this._box_0 = t0;
        this.$this = t1;
      },
      _Future__chainForeignFuture_closure: function _Future__chainForeignFuture_closure(t0) {
        this.$this = t0;
      },
      _Future__chainForeignFuture_closure0: function _Future__chainForeignFuture_closure0(t0) {
        this.$this = t0;
      },
      _Future__chainForeignFuture_closure1: function _Future__chainForeignFuture_closure1(t0, t1, t2) {
        this.$this = t0;
        this.e = t1;
        this.s = t2;
      },
      _Future__propagateToListeners_handleWhenCompleteCallback: function _Future__propagateToListeners_handleWhenCompleteCallback(t0, t1, t2) {
        this._box_0 = t0;
        this._box_1 = t1;
        this.hasError = t2;
      },
      _Future__propagateToListeners_handleWhenCompleteCallback_closure: function _Future__propagateToListeners_handleWhenCompleteCallback_closure(t0) {
        this.originalSource = t0;
      },
      _Future__propagateToListeners_handleValueCallback: function _Future__propagateToListeners_handleValueCallback(t0, t1) {
        this._box_0 = t0;
        this.sourceResult = t1;
      },
      _Future__propagateToListeners_handleError: function _Future__propagateToListeners_handleError(t0, t1) {
        this._box_1 = t0;
        this._box_0 = t1;
      },
      _AsyncCallbackEntry: function _AsyncCallbackEntry(t0) {
        this.callback = t0;
        this.next = null;
      },
      _Zone: function _Zone() {
      },
      _rootHandleError_closure: function _rootHandleError_closure(t0, t1) {
        this.error = t0;
        this.stackTrace = t1;
      },
      _RootZone: function _RootZone() {
      },
      _RootZone_bindCallbackGuarded_closure: function _RootZone_bindCallbackGuarded_closure(t0, t1) {
        this.$this = t0;
        this.f = t1;
      },
      Error__throw(error, stackTrace) {
        error = A.wrapException(error);
        if (error == null)
          error = type$.Object._as(error);
        error.stack = stackTrace.toString$0(0);
        throw error;
        throw A.wrapException("unreachable");
      },
      StringBuffer__writeAll(string, objects, separator) {
        var t2,
          t1 = A._arrayInstanceType(objects),
          iterator = new J.ArrayIterator(objects, objects.length, t1._eval$1("ArrayIterator<1>"));
        if (!iterator.moveNext$0())
          return string;
        if (separator.length === 0) {
          t1 = t1._precomputed1;
          do {
            t2 = iterator._current;
            string += A.S(t2 == null ? t1._as(t2) : t2);
          } while (iterator.moveNext$0());
        } else {
          t2 = iterator._current;
          string += A.S(t2 == null ? t1._precomputed1._as(t2) : t2);
          for (t1 = t1._precomputed1; iterator.moveNext$0();) {
            t2 = iterator._current;
            string = string + separator + A.S(t2 == null ? t1._as(t2) : t2);
          }
        }
        return string;
      },
      Error_safeToString(object) {
        if (typeof object == "number" || A._isBool(object) || object == null)
          return J.toString$0$(object);
        if (typeof object == "string")
          return JSON.stringify(object);
        return A.Primitives_safeToString(object);
      },
      Error_throwWithStackTrace(error, stackTrace) {
        A.checkNotNullable(error, "error", type$.Object);
        A.checkNotNullable(stackTrace, "stackTrace", type$.StackTrace);
        A.Error__throw(error, stackTrace);
      },
      AssertionError$(message) {
        return new A.AssertionError(message);
      },
      ArgumentError$(message, $name) {
        return new A.ArgumentError(false, null, $name, message);
      },
      ArgumentError$value(value, $name, message) {
        return new A.ArgumentError(true, value, $name, message);
      },
      UnsupportedError$(message) {
        return new A.UnsupportedError(message);
      },
      Iterable_iterableToFullString(iterable, leftDelimiter, rightDelimiter) {
        var buffer, t1;
        if (A.isToStringVisiting(iterable))
          return leftDelimiter + "..." + rightDelimiter;
        buffer = new A.StringBuffer(leftDelimiter);
        B.JSArray_methods.add$1($.toStringVisiting, iterable);
        try {
          t1 = buffer;
          t1._contents = A.StringBuffer__writeAll(t1._contents, iterable, ", ");
        } finally {
          if (0 >= $.toStringVisiting.length)
            return A.ioore($.toStringVisiting, -1);
          $.toStringVisiting.pop();
        }
        buffer._contents += rightDelimiter;
        t1 = buffer._contents;
        return t1.charCodeAt(0) == 0 ? t1 : t1;
      },
      print(object) {
        A.printString(A.S(object));
      },
      Duration: function Duration(t0) {
        this._duration = t0;
      },
      Error: function Error() {
      },
      AssertionError: function AssertionError(t0) {
        this.message = t0;
      },
      TypeError: function TypeError() {
      },
      ArgumentError: function ArgumentError(t0, t1, t2, t3) {
        var _ = this;
        _._hasValue = t0;
        _.invalidValue = t1;
        _.name = t2;
        _.message = t3;
      },
      RangeError: function RangeError(t0, t1, t2, t3) {
        var _ = this;
        _._hasValue = t0;
        _.invalidValue = t1;
        _.name = t2;
        _.message = t3;
      },
      IndexError: function IndexError(t0, t1, t2, t3, t4) {
        var _ = this;
        _.length = t0;
        _._hasValue = t1;
        _.invalidValue = t2;
        _.name = t3;
        _.message = t4;
      },
      UnsupportedError: function UnsupportedError(t0) {
        this.message = t0;
      },
      ConcurrentModificationError: function ConcurrentModificationError(t0) {
        this.modifiedObject = t0;
      },
      OutOfMemoryError: function OutOfMemoryError() {
      },
      StackOverflowError: function StackOverflowError() {
      },
      _Exception: function _Exception(t0) {
        this.message = t0;
      },
      Null: function Null() {
      },
      Object: function Object() {
      },
      _StringStackTrace: function _StringStackTrace() {
      },
      StringBuffer: function StringBuffer(t0) {
        this._contents = t0;
      },
      main() {
        var a, i, b,
          _s13_ = "Hello, World!";
        A.print(_s13_);
        for (a = _s13_, i = 0; i < 10; ++i)
          a += " " + B.JSInt_methods.toString$0(i);
        for (b = 12242424242424, i = 0; i < 10; ++i)
          b += b * i;
        A.Future_Future$delayed(new A.Duration(1000000), type$.dynamic).then$1$1(new A.main_closure(), type$.Null);
        new A.main_closure0().call$0();
        A.print(a);
      },
      main_closure: function main_closure() {
      },
      main_closure0: function main_closure0() {
      },
      printString(string) {
        if (typeof dartPrint == "function") {
          dartPrint(string);
          return;
        }
        if (typeof console == "object" && typeof console.log != "undefined") {
          console.log(string);
          return;
        }
        if (typeof print == "function") {
          print(string);
          return;
        }
        throw "Unable to print message: " + String(string);
      },
      throwLateFieldADI(fieldName) {
        A.throwExpressionWithWrapper(new A.LateError("Field '" + fieldName + "' has been assigned during initialization."), new Error());
      }
    },
    B = {};
  var holders = [A, J, B];
  var $ = {};
  A.JS_CONST.prototype = {};
  J.Interceptor.prototype = {
    toString$0(receiver) {
      return "Instance of '" + A.Primitives_objectTypeName(receiver) + "'";
    },
    get$runtimeType(receiver) {
      return A.createRuntimeType(A._instanceTypeFromConstructor(this));
    }
  };
  J.JSBool.prototype = {
    toString$0(receiver) {
      return String(receiver);
    },
    get$runtimeType(receiver) {
      return A.createRuntimeType(type$.bool);
    },
    $isTrustedGetRuntimeType: 1,
    $isbool: 1
  };
  J.JSNull.prototype = {
    toString$0(receiver) {
      return "null";
    },
    $isTrustedGetRuntimeType: 1,
    $isNull: 1
  };
  J.JavaScriptObject.prototype = {};
  J.LegacyJavaScriptObject.prototype = {
    toString$0(receiver) {
      return String(receiver);
    }
  };
  J.PlainJavaScriptObject.prototype = {};
  J.UnknownJavaScriptObject.prototype = {};
  J.JSArray.prototype = {
    add$1(receiver, value) {
      A._arrayInstanceType(receiver)._precomputed1._as(value);
      if (!!receiver.fixed$length)
        A.throwExpression(A.UnsupportedError$("add"));
      receiver.push(value);
    },
    toString$0(receiver) {
      return A.Iterable_iterableToFullString(receiver, "[", "]");
    },
    get$length(receiver) {
      return receiver.length;
    },
    $isIterable: 1
  };
  J.JSUnmodifiableArray.prototype = {};
  J.ArrayIterator.prototype = {
    moveNext$0() {
      var t2, _this = this,
        t1 = _this._iterable,
        $length = t1.length;
      if (_this._length !== $length) {
        t1 = A.throwConcurrentModificationError(t1);
        throw A.wrapException(t1);
      }
      t2 = _this._index;
      if (t2 >= $length) {
        _this.set$_current(null);
        return false;
      }
      _this.set$_current(t1[t2]);
      ++_this._index;
      return true;
    },
    set$_current(_current) {
      this._current = this.$ti._eval$1("1?")._as(_current);
    }
  };
  J.JSNumber.prototype = {
    toString$0(receiver) {
      if (receiver === 0 && 1 / receiver < 0)
        return "-0.0";
      else
        return "" + receiver;
    },
    _tdivFast$1(receiver, other) {
      return (receiver | 0) === receiver ? receiver / other | 0 : this._tdivSlow$1(receiver, other);
    },
    _tdivSlow$1(receiver, other) {
      var quotient = receiver / other;
      if (quotient >= -2147483648 && quotient <= 2147483647)
        return quotient | 0;
      if (quotient > 0) {
        if (quotient !== 1 / 0)
          return Math.floor(quotient);
      } else if (quotient > -1 / 0)
        return Math.ceil(quotient);
      throw A.wrapException(A.UnsupportedError$("Result of truncating division is " + A.S(quotient) + ": " + A.S(receiver) + " ~/ " + other));
    },
    _shrOtherPositive$1(receiver, other) {
      var t1;
      if (receiver > 0)
        t1 = this._shrBothPositive$1(receiver, other);
      else {
        t1 = other > 31 ? 31 : other;
        t1 = receiver >> t1 >>> 0;
      }
      return t1;
    },
    _shrBothPositive$1(receiver, other) {
      return other > 31 ? 0 : receiver >>> other;
    },
    get$runtimeType(receiver) {
      return A.createRuntimeType(type$.num);
    },
    $isnum: 1
  };
  J.JSInt.prototype = {
    get$runtimeType(receiver) {
      return A.createRuntimeType(type$.int);
    },
    $isTrustedGetRuntimeType: 1,
    $isint: 1
  };
  J.JSNumNotInt.prototype = {
    get$runtimeType(receiver) {
      return A.createRuntimeType(type$.double);
    },
    $isTrustedGetRuntimeType: 1
  };
  J.JSString.prototype = {
    $add(receiver, other) {
      return receiver + other;
    },
    $mul(receiver, times) {
      var s, result;
      if (0 >= times)
        return "";
      if (times === 1 || receiver.length === 0)
        return receiver;
      if (times !== times >>> 0)
        throw A.wrapException(B.C_OutOfMemoryError);
      for (s = receiver, result = ""; true;) {
        if ((times & 1) === 1)
          result = s + result;
        times = times >>> 1;
        if (times === 0)
          break;
        s += s;
      }
      return result;
    },
    padLeft$2(receiver, width, padding) {
      var delta = width - receiver.length;
      if (delta <= 0)
        return receiver;
      return this.$mul(padding, delta) + receiver;
    },
    toString$0(receiver) {
      return receiver;
    },
    get$runtimeType(receiver) {
      return A.createRuntimeType(type$.String);
    },
    get$length(receiver) {
      return receiver.length;
    },
    $isTrustedGetRuntimeType: 1,
    $isString: 1
  };
  A.LateError.prototype = {
    toString$0(_) {
      return "LateInitializationError: " + this._message;
    }
  };
  A.TypeErrorDecoder.prototype = {
    matchTypeError$1(message) {
      var result, t1, _this = this,
        match = new RegExp(_this._pattern).exec(message);
      if (match == null)
        return null;
      result = Object.create(null);
      t1 = _this._arguments;
      if (t1 !== -1)
        result.arguments = match[t1 + 1];
      t1 = _this._argumentsExpr;
      if (t1 !== -1)
        result.argumentsExpr = match[t1 + 1];
      t1 = _this._expr;
      if (t1 !== -1)
        result.expr = match[t1 + 1];
      t1 = _this._method;
      if (t1 !== -1)
        result.method = match[t1 + 1];
      t1 = _this._receiver;
      if (t1 !== -1)
        result.receiver = match[t1 + 1];
      return result;
    }
  };
  A.NullError.prototype = {
    toString$0(_) {
      return "Null check operator used on a null value";
    }
  };
  A.JsNoSuchMethodError.prototype = {
    toString$0(_) {
      var t2, _this = this,
        _s38_ = "NoSuchMethodError: method not found: '",
        t1 = _this._method;
      if (t1 == null)
        return "NoSuchMethodError: " + _this.__js_helper$_message;
      t2 = _this._receiver;
      if (t2 == null)
        return _s38_ + t1 + "' (" + _this.__js_helper$_message + ")";
      return _s38_ + t1 + "' on '" + t2 + "' (" + _this.__js_helper$_message + ")";
    }
  };
  A.UnknownJsTypeError.prototype = {
    toString$0(_) {
      var t1 = this.__js_helper$_message;
      return t1.length === 0 ? "Error" : "Error: " + t1;
    }
  };
  A.NullThrownFromJavaScriptException.prototype = {
    toString$0(_) {
      return "Throw of null ('" + (this._irritant === null ? "null" : "undefined") + "' from JavaScript)";
    }
  };
  A._StackTrace.prototype = {
    toString$0(_) {
      var trace,
        t1 = this._trace;
      if (t1 != null)
        return t1;
      t1 = this._exception;
      trace = t1 !== null && typeof t1 === "object" ? t1.stack : null;
      return this._trace = trace == null ? "" : trace;
    },
    $isStackTrace: 1
  };
  A.Closure.prototype = {
    toString$0(_) {
      var $constructor = this.constructor,
        $name = $constructor == null ? null : $constructor.name;
      return "Closure '" + A.unminifyOrTag($name == null ? "unknown" : $name) + "'";
    },
    $isFunction: 1,
    get$$call() {
      return this;
    },
    "call*": "call$1",
    $requiredArgCount: 1,
    $defaultValues: null
  };
  A.Closure0Args.prototype = { "call*": "call$0", $requiredArgCount: 0 };
  A.Closure2Args.prototype = { "call*": "call$2", $requiredArgCount: 2 };
  A.TearOffClosure.prototype = {};
  A.StaticClosure.prototype = {
    toString$0(_) {
      var $name = this.$static_name;
      if ($name == null)
        return "Closure of unknown static method";
      return "Closure '" + A.unminifyOrTag($name) + "'";
    }
  };
  A.BoundClosure.prototype = {
    toString$0(_) {
      return "Closure '" + this.$_name + "' of " + ("Instance of '" + A.Primitives_objectTypeName(this._receiver) + "'");
    }
  };
  A._CyclicInitializationError.prototype = {
    toString$0(_) {
      return "Reading static variable '" + this.variableName + "' during its initialization";
    }
  };
  A.RuntimeError.prototype = {
    toString$0(_) {
      return "RuntimeError: " + this.message;
    }
  };
  A.Rti.prototype = {
    _eval$1(recipe) {
      return A._Universe_evalInEnvironment(init.typeUniverse, this, recipe);
    },
    _bind$1(typeOrTuple) {
      return A._Universe_bind(init.typeUniverse, this, typeOrTuple);
    }
  };
  A._FunctionParameters.prototype = {};
  A._Type.prototype = {
    toString$0(_) {
      return A._rtiToString(this._rti, null);
    }
  };
  A._Error.prototype = {
    toString$0(_) {
      return this.__rti$_message;
    }
  };
  A._TypeError.prototype = { $isTypeError: 1 };
  A._AsyncRun__initializeScheduleImmediate_internalCallback.prototype = {
    call$1(_) {
      var t1 = this._box_0,
        f = t1.storedCallback;
      t1.storedCallback = null;
      f.call$0();
    },
    $signature: 1
  };
  A._AsyncRun__initializeScheduleImmediate_closure.prototype = {
    call$1(callback) {
      var t1, t2;
      this._box_0.storedCallback = type$.void_Function._as(callback);
      t1 = this.div;
      t2 = this.span;
      t1.firstChild ? t1.removeChild(t2) : t1.appendChild(t2);
    },
    $signature: 4
  };
  A._AsyncRun__scheduleImmediateJsOverride_internalCallback.prototype = {
    call$0() {
      this.callback.call$0();
    },
    $signature: 2
  };
  A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback.prototype = {
    call$0() {
      this.callback.call$0();
    },
    $signature: 2
  };
  A._TimerImpl.prototype = {
    _TimerImpl$2(milliseconds, callback) {
      if (self.setTimeout != null)
        self.setTimeout(A.convertDartClosureToJS(new A._TimerImpl_internalCallback(this, callback), 0), milliseconds);
      else
        throw A.wrapException(A.UnsupportedError$("`setTimeout()` not found."));
    }
  };
  A._TimerImpl_internalCallback.prototype = {
    call$0() {
      this.callback.call$0();
    },
    $signature: 0
  };
  A.AsyncError.prototype = {
    toString$0(_) {
      return A.S(this.error);
    },
    $isError: 1,
    get$stackTrace() {
      return this.stackTrace;
    }
  };
  A.Future_Future$delayed_closure.prototype = {
    call$0() {
      this.T._as(null);
      this.result._complete$1(null);
    },
    $signature: 0
  };
  A._FutureListener.prototype = {
    matchesErrorTest$1(asyncError) {
      if ((this.state & 15) !== 6)
        return true;
      return this.result._zone.runUnary$2$2(type$.bool_Function_Object._as(this.callback), asyncError.error, type$.bool, type$.Object);
    },
    handleError$1(asyncError) {
      var exception, _this = this,
        errorCallback = _this.errorCallback,
        result = null,
        t1 = type$.dynamic,
        t2 = type$.Object,
        t3 = asyncError.error,
        t4 = _this.result._zone;
      if (type$.dynamic_Function_Object_StackTrace._is(errorCallback))
        result = t4.runBinary$3$3(errorCallback, t3, asyncError.stackTrace, t1, t2, type$.StackTrace);
      else
        result = t4.runUnary$2$2(type$.dynamic_Function_Object._as(errorCallback), t3, t1, t2);
      try {
        t1 = _this.$ti._eval$1("2/")._as(result);
        return t1;
      } catch (exception) {
        if (type$.TypeError._is(A.unwrapException(exception))) {
          if ((_this.state & 1) !== 0)
            throw A.wrapException(A.ArgumentError$("The error handler of Future.then must return a value of the returned future's type", "onError"));
          throw A.wrapException(A.ArgumentError$("The error handler of Future.catchError must return a value of the future's type", "onError"));
        } else
          throw exception;
      }
    }
  };
  A._Future.prototype = {
    then$1$2$onError(f, onError, $R) {
      var currentZone, result, t2,
        t1 = this.$ti;
      t1._bind$1($R)._eval$1("1/(2)")._as(f);
      currentZone = $.Zone__current;
      if (currentZone === B.C__RootZone) {
        if (onError != null && !type$.dynamic_Function_Object_StackTrace._is(onError) && !type$.dynamic_Function_Object._is(onError))
          throw A.wrapException(A.ArgumentError$value(onError, "onError", string$.Error_));
      } else {
        $R._eval$1("@<0/>")._bind$1(t1._precomputed1)._eval$1("1(2)")._as(f);
        if (onError != null)
          onError = A._registerErrorHandler(onError, currentZone);
      }
      result = new A._Future(currentZone, $R._eval$1("_Future<0>"));
      t2 = onError == null ? 1 : 3;
      this._addListener$1(new A._FutureListener(result, t2, f, onError, t1._eval$1("@<1>")._bind$1($R)._eval$1("_FutureListener<1,2>")));
      return result;
    },
    then$1$1(f, $R) {
      return this.then$1$2$onError(f, null, $R);
    },
    _setErrorObject$1(error) {
      this._state = this._state & 1 | 16;
      this._resultOrListeners = error;
    },
    _cloneResult$1(source) {
      this._state = source._state & 30 | this._state & 1;
      this._resultOrListeners = source._resultOrListeners;
    },
    _addListener$1(listener) {
      var source, _this = this,
        t1 = _this._state;
      if (t1 <= 3) {
        listener._nextListener = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
        _this._resultOrListeners = listener;
      } else {
        if ((t1 & 4) !== 0) {
          source = type$._Future_dynamic._as(_this._resultOrListeners);
          if ((source._state & 24) === 0) {
            source._addListener$1(listener);
            return;
          }
          _this._cloneResult$1(source);
        }
        A._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new A._Future__addListener_closure(_this, listener)));
      }
    },
    _prependListeners$1(listeners) {
      var t1, existingListeners, next, cursor, next0, source, _this = this, _box_0 = {};
      _box_0.listeners = listeners;
      if (listeners == null)
        return;
      t1 = _this._state;
      if (t1 <= 3) {
        existingListeners = type$.nullable__FutureListener_dynamic_dynamic._as(_this._resultOrListeners);
        _this._resultOrListeners = listeners;
        if (existingListeners != null) {
          next = listeners._nextListener;
          for (cursor = listeners; next != null; cursor = next, next = next0)
            next0 = next._nextListener;
          cursor._nextListener = existingListeners;
        }
      } else {
        if ((t1 & 4) !== 0) {
          source = type$._Future_dynamic._as(_this._resultOrListeners);
          if ((source._state & 24) === 0) {
            source._prependListeners$1(listeners);
            return;
          }
          _this._cloneResult$1(source);
        }
        _box_0.listeners = _this._reverseListeners$1(listeners);
        A._rootScheduleMicrotask(null, null, _this._zone, type$.void_Function._as(new A._Future__prependListeners_closure(_box_0, _this)));
      }
    },
    _removeListeners$0() {
      var current = type$.nullable__FutureListener_dynamic_dynamic._as(this._resultOrListeners);
      this._resultOrListeners = null;
      return this._reverseListeners$1(current);
    },
    _reverseListeners$1(listeners) {
      var current, prev, next;
      for (current = listeners, prev = null; current != null; prev = current, current = next) {
        next = current._nextListener;
        current._nextListener = prev;
      }
      return prev;
    },
    _chainForeignFuture$1(source) {
      var e, s, exception, _this = this;
      _this._state ^= 2;
      try {
        source.then$1$2$onError(new A._Future__chainForeignFuture_closure(_this), new A._Future__chainForeignFuture_closure0(_this), type$.Null);
      } catch (exception) {
        e = A.unwrapException(exception);
        s = A.getTraceFromException(exception);
        A.scheduleMicrotask(new A._Future__chainForeignFuture_closure1(_this, e, s));
      }
    },
    _complete$1(value) {
      var listeners, _this = this,
        t1 = _this.$ti;
      t1._eval$1("1/")._as(value);
      if (t1._eval$1("Future<1>")._is(value))
        _this._chainForeignFuture$1(value);
      else {
        listeners = _this._removeListeners$0();
        t1._precomputed1._as(value);
        _this._state = 8;
        _this._resultOrListeners = value;
        A._Future__propagateToListeners(_this, listeners);
      }
    },
    _completeError$2(error, stackTrace) {
      var listeners;
      type$.StackTrace._as(stackTrace);
      listeners = this._removeListeners$0();
      this._setErrorObject$1(A.AsyncError$(error, stackTrace));
      A._Future__propagateToListeners(this, listeners);
    },
    $isFuture: 1
  };
  A._Future__addListener_closure.prototype = {
    call$0() {
      A._Future__propagateToListeners(this.$this, this.listener);
    },
    $signature: 0
  };
  A._Future__prependListeners_closure.prototype = {
    call$0() {
      A._Future__propagateToListeners(this.$this, this._box_0.listeners);
    },
    $signature: 0
  };
  A._Future__chainForeignFuture_closure.prototype = {
    call$1(value) {
      var error, stackTrace, t2, listeners, exception,
        t1 = this.$this;
      t1._state ^= 2;
      try {
        t2 = t1.$ti._precomputed1;
        value = t2._as(t2._as(value));
        listeners = t1._removeListeners$0();
        t1._state = 8;
        t1._resultOrListeners = value;
        A._Future__propagateToListeners(t1, listeners);
      } catch (exception) {
        error = A.unwrapException(exception);
        stackTrace = A.getTraceFromException(exception);
        t1._completeError$2(error, stackTrace);
      }
    },
    $signature: 1
  };
  A._Future__chainForeignFuture_closure0.prototype = {
    call$2(error, stackTrace) {
      this.$this._completeError$2(type$.Object._as(error), type$.StackTrace._as(stackTrace));
    },
    $signature: 5
  };
  A._Future__chainForeignFuture_closure1.prototype = {
    call$0() {
      this.$this._completeError$2(this.e, this.s);
    },
    $signature: 0
  };
  A._Future__propagateToListeners_handleWhenCompleteCallback.prototype = {
    call$0() {
      var e, s, t1, exception, t2, originalSource, _this = this, completeResult = null;
      try {
        t1 = _this._box_0.listener;
        completeResult = t1.result._zone.run$1$1(type$.dynamic_Function._as(t1.callback), type$.dynamic);
      } catch (exception) {
        e = A.unwrapException(exception);
        s = A.getTraceFromException(exception);
        t1 = _this.hasError && type$.AsyncError._as(_this._box_1.source._resultOrListeners).error === e;
        t2 = _this._box_0;
        if (t1)
          t2.listenerValueOrError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
        else
          t2.listenerValueOrError = A.AsyncError$(e, s);
        t2.listenerHasError = true;
        return;
      }
      if (completeResult instanceof A._Future && (completeResult._state & 24) !== 0) {
        if ((completeResult._state & 16) !== 0) {
          t1 = _this._box_0;
          t1.listenerValueOrError = type$.AsyncError._as(completeResult._resultOrListeners);
          t1.listenerHasError = true;
        }
        return;
      }
      if (completeResult instanceof A._Future) {
        originalSource = _this._box_1.source;
        t1 = _this._box_0;
        t1.listenerValueOrError = completeResult.then$1$1(new A._Future__propagateToListeners_handleWhenCompleteCallback_closure(originalSource), type$.dynamic);
        t1.listenerHasError = false;
      }
    },
    $signature: 0
  };
  A._Future__propagateToListeners_handleWhenCompleteCallback_closure.prototype = {
    call$1(_) {
      return this.originalSource;
    },
    $signature: 6
  };
  A._Future__propagateToListeners_handleValueCallback.prototype = {
    call$0() {
      var e, s, t1, t2, t3, t4, t5, exception;
      try {
        t1 = this._box_0;
        t2 = t1.listener;
        t3 = t2.$ti;
        t4 = t3._precomputed1;
        t5 = t4._as(this.sourceResult);
        t1.listenerValueOrError = t2.result._zone.runUnary$2$2(t3._eval$1("2/(1)")._as(t2.callback), t5, t3._eval$1("2/"), t4);
      } catch (exception) {
        e = A.unwrapException(exception);
        s = A.getTraceFromException(exception);
        t1 = this._box_0;
        t1.listenerValueOrError = A.AsyncError$(e, s);
        t1.listenerHasError = true;
      }
    },
    $signature: 0
  };
  A._Future__propagateToListeners_handleError.prototype = {
    call$0() {
      var asyncError, e, s, t1, exception, t2, _this = this;
      try {
        asyncError = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
        t1 = _this._box_0;
        if (t1.listener.matchesErrorTest$1(asyncError) && t1.listener.errorCallback != null) {
          t1.listenerValueOrError = t1.listener.handleError$1(asyncError);
          t1.listenerHasError = false;
        }
      } catch (exception) {
        e = A.unwrapException(exception);
        s = A.getTraceFromException(exception);
        t1 = type$.AsyncError._as(_this._box_1.source._resultOrListeners);
        t2 = _this._box_0;
        if (t1.error === e)
          t2.listenerValueOrError = t1;
        else
          t2.listenerValueOrError = A.AsyncError$(e, s);
        t2.listenerHasError = true;
      }
    },
    $signature: 0
  };
  A._AsyncCallbackEntry.prototype = {};
  A._Zone.prototype = { $isZone: 1 };
  A._rootHandleError_closure.prototype = {
    call$0() {
      A.Error_throwWithStackTrace(this.error, this.stackTrace);
    },
    $signature: 0
  };
  A._RootZone.prototype = {
    runGuarded$1(f) {
      var e, s, exception;
      type$.void_Function._as(f);
      try {
        if (B.C__RootZone === $.Zone__current) {
          f.call$0();
          return;
        }
        A._rootRun(null, null, this, f, type$.void);
      } catch (exception) {
        e = A.unwrapException(exception);
        s = A.getTraceFromException(exception);
        A._rootHandleError(type$.Object._as(e), type$.StackTrace._as(s));
      }
    },
    bindCallbackGuarded$1(f) {
      return new A._RootZone_bindCallbackGuarded_closure(this, type$.void_Function._as(f));
    },
    run$1$1(f, $R) {
      $R._eval$1("0()")._as(f);
      if ($.Zone__current === B.C__RootZone)
        return f.call$0();
      return A._rootRun(null, null, this, f, $R);
    },
    runUnary$2$2(f, arg, $R, $T) {
      $R._eval$1("@<0>")._bind$1($T)._eval$1("1(2)")._as(f);
      $T._as(arg);
      if ($.Zone__current === B.C__RootZone)
        return f.call$1(arg);
      return A._rootRunUnary(null, null, this, f, arg, $R, $T);
    },
    runBinary$3$3(f, arg1, arg2, $R, T1, T2) {
      $R._eval$1("@<0>")._bind$1(T1)._bind$1(T2)._eval$1("1(2,3)")._as(f);
      T1._as(arg1);
      T2._as(arg2);
      if ($.Zone__current === B.C__RootZone)
        return f.call$2(arg1, arg2);
      return A._rootRunBinary(null, null, this, f, arg1, arg2, $R, T1, T2);
    }
  };
  A._RootZone_bindCallbackGuarded_closure.prototype = {
    call$0() {
      return this.$this.runGuarded$1(this.f);
    },
    $signature: 0
  };
  A.Duration.prototype = {
    toString$0(_) {
      var minutes, minutesPadding, seconds, secondsPadding,
        microseconds = this._duration,
        hours = B.JSInt_methods._tdivFast$1(microseconds, 3600000000);
      microseconds %= 3600000000;
      minutes = B.JSInt_methods._tdivFast$1(microseconds, 60000000);
      microseconds %= 60000000;
      minutesPadding = minutes < 10 ? "0" : "";
      seconds = B.JSInt_methods._tdivFast$1(microseconds, 1000000);
      secondsPadding = seconds < 10 ? "0" : "";
      return "" + hours + ":" + minutesPadding + minutes + ":" + secondsPadding + seconds + "." + B.JSString_methods.padLeft$2(B.JSInt_methods.toString$0(microseconds % 1000000), 6, "0");
    }
  };
  A.Error.prototype = {
    get$stackTrace() {
      return A.getTraceFromException(this.$thrownJsError);
    }
  };
  A.AssertionError.prototype = {
    toString$0(_) {
      var t1 = this.message;
      if (t1 != null)
        return "Assertion failed: " + A.Error_safeToString(t1);
      return "Assertion failed";
    }
  };
  A.TypeError.prototype = {};
  A.ArgumentError.prototype = {
    get$_errorName() {
      return "Invalid argument" + (!this._hasValue ? "(s)" : "");
    },
    get$_errorExplanation() {
      return "";
    },
    toString$0(_) {
      var _this = this,
        $name = _this.name,
        nameString = $name == null ? "" : " (" + $name + ")",
        message = _this.message,
        messageString = message == null ? "" : ": " + message,
        prefix = _this.get$_errorName() + nameString + messageString;
      if (!_this._hasValue)
        return prefix;
      return prefix + _this.get$_errorExplanation() + ": " + A.Error_safeToString(_this.get$invalidValue());
    },
    get$invalidValue() {
      return this.invalidValue;
    }
  };
  A.RangeError.prototype = {
    get$invalidValue() {
      return A._asNumQ(this.invalidValue);
    },
    get$_errorName() {
      return "RangeError";
    },
    get$_errorExplanation() {
      return "";
    }
  };
  A.IndexError.prototype = {
    get$invalidValue() {
      return A._asInt(this.invalidValue);
    },
    get$_errorName() {
      return "RangeError";
    },
    get$_errorExplanation() {
      if (A._asInt(this.invalidValue) < 0)
        return ": index must not be negative";
      var t1 = this.length;
      if (t1 === 0)
        return ": no indices are valid";
      return ": index should be less than " + t1;
    },
    get$length(receiver) {
      return this.length;
    }
  };
  A.UnsupportedError.prototype = {
    toString$0(_) {
      return "Unsupported operation: " + this.message;
    }
  };
  A.ConcurrentModificationError.prototype = {
    toString$0(_) {
      return "Concurrent modification during iteration: " + A.Error_safeToString(this.modifiedObject) + ".";
    }
  };
  A.OutOfMemoryError.prototype = {
    toString$0(_) {
      return "Out of Memory";
    },
    get$stackTrace() {
      return null;
    },
    $isError: 1
  };
  A.StackOverflowError.prototype = {
    toString$0(_) {
      return "Stack Overflow";
    },
    get$stackTrace() {
      return null;
    },
    $isError: 1
  };
  A._Exception.prototype = {
    toString$0(_) {
      return "Exception: " + this.message;
    }
  };
  A.Null.prototype = {
    toString$0(_) {
      return "null";
    }
  };
  A.Object.prototype = {
    $isObject: 1,
    toString$0(_) {
      return "Instance of '" + A.Primitives_objectTypeName(this) + "'";
    },
    get$runtimeType(_) {
      return A.getRuntimeTypeOfDartObject(this);
    },
    toString() {
      return this.toString$0(this);
    }
  };
  A._StringStackTrace.prototype = {
    toString$0(_) {
      return "";
    },
    $isStackTrace: 1
  };
  A.StringBuffer.prototype = {
    get$length(_) {
      return this._contents.length;
    },
    toString$0(_) {
      var t1 = this._contents;
      return t1.charCodeAt(0) == 0 ? t1 : t1;
    }
  };
  A.main_closure.prototype = {
    call$1(value) {
      A.print("\u5ef6\u65f61\u79d2\u6267\u884c then ");
      A.print(value);
    },
    $signature: 1
  };
  A.main_closure0.prototype = {
    call$0() {
      A.print("closuer");
    },
    $signature: 2
  };
  (function installTearOffs() {
    var _static_1 = hunkHelpers._static_1,
      _static_0 = hunkHelpers._static_0;
    _static_1(A, "async__AsyncRun__scheduleImmediateJsOverride$closure", "_AsyncRun__scheduleImmediateJsOverride", 3);
    _static_1(A, "async__AsyncRun__scheduleImmediateWithSetImmediate$closure", "_AsyncRun__scheduleImmediateWithSetImmediate", 3);
    _static_1(A, "async__AsyncRun__scheduleImmediateWithTimer$closure", "_AsyncRun__scheduleImmediateWithTimer", 3);
    _static_0(A, "async___startMicrotaskLoop$closure", "_startMicrotaskLoop", 0);
  })();
  (function inheritance() {
    var _inherit = hunkHelpers.inherit,
      _inheritMany = hunkHelpers.inheritMany;
    _inherit(A.Object, null);
    _inheritMany(A.Object, [A.JS_CONST, J.Interceptor, J.ArrayIterator, A.Error, A.TypeErrorDecoder, A.NullThrownFromJavaScriptException, A._StackTrace, A.Closure, A.Rti, A._FunctionParameters, A._Type, A._TimerImpl, A.AsyncError, A._FutureListener, A._Future, A._AsyncCallbackEntry, A._Zone, A.Duration, A.OutOfMemoryError, A.StackOverflowError, A._Exception, A.Null, A._StringStackTrace, A.StringBuffer]);
    _inheritMany(J.Interceptor, [J.JSBool, J.JSNull, J.JavaScriptObject, J.JSNumber, J.JSString]);
    _inheritMany(J.JavaScriptObject, [J.LegacyJavaScriptObject, J.JSArray]);
    _inheritMany(J.LegacyJavaScriptObject, [J.PlainJavaScriptObject, J.UnknownJavaScriptObject]);
    _inherit(J.JSUnmodifiableArray, J.JSArray);
    _inheritMany(J.JSNumber, [J.JSInt, J.JSNumNotInt]);
    _inheritMany(A.Error, [A.LateError, A.TypeError, A.JsNoSuchMethodError, A.UnknownJsTypeError, A._CyclicInitializationError, A.RuntimeError, A._Error, A.AssertionError, A.ArgumentError, A.UnsupportedError, A.ConcurrentModificationError]);
    _inherit(A.NullError, A.TypeError);
    _inheritMany(A.Closure, [A.Closure0Args, A.Closure2Args, A.TearOffClosure, A._AsyncRun__initializeScheduleImmediate_internalCallback, A._AsyncRun__initializeScheduleImmediate_closure, A._Future__chainForeignFuture_closure, A._Future__propagateToListeners_handleWhenCompleteCallback_closure, A.main_closure]);
    _inheritMany(A.TearOffClosure, [A.StaticClosure, A.BoundClosure]);
    _inherit(A._TypeError, A._Error);
    _inheritMany(A.Closure0Args, [A._AsyncRun__scheduleImmediateJsOverride_internalCallback, A._AsyncRun__scheduleImmediateWithSetImmediate_internalCallback, A._TimerImpl_internalCallback, A.Future_Future$delayed_closure, A._Future__addListener_closure, A._Future__prependListeners_closure, A._Future__chainForeignFuture_closure1, A._Future__propagateToListeners_handleWhenCompleteCallback, A._Future__propagateToListeners_handleValueCallback, A._Future__propagateToListeners_handleError, A._rootHandleError_closure, A._RootZone_bindCallbackGuarded_closure, A.main_closure0]);
    _inherit(A._Future__chainForeignFuture_closure0, A.Closure2Args);
    _inherit(A._RootZone, A._Zone);
    _inheritMany(A.ArgumentError, [A.RangeError, A.IndexError]);
  })();
  var init = {
    typeUniverse: { eC: new Map(), tR: {}, eT: {}, tPV: {}, sEA: [] },
    mangledGlobalNames: { int: "int", double: "double", num: "num", String: "String", bool: "bool", Null: "Null", List: "List", Object: "Object", Map: "Map" },
    mangledNames: {},
    types: ["~()", "Null(@)", "Null()", "~(~())", "Null(~())", "Null(Object,StackTrace)", "_Future<@>(@)"],
    arrayRti: Symbol("$ti")
  };
  A._Universe_addRules(init.typeUniverse, JSON.parse('{"PlainJavaScriptObject":"LegacyJavaScriptObject","UnknownJavaScriptObject":"LegacyJavaScriptObject","JSBool":{"bool":[],"TrustedGetRuntimeType":[]},"JSNull":{"Null":[],"TrustedGetRuntimeType":[]},"JSArray":{"Iterable":["1"]},"JSUnmodifiableArray":{"JSArray":["1"],"Iterable":["1"]},"JSNumber":{"num":[]},"JSInt":{"int":[],"num":[],"TrustedGetRuntimeType":[]},"JSNumNotInt":{"num":[],"TrustedGetRuntimeType":[]},"JSString":{"String":[],"TrustedGetRuntimeType":[]},"LateError":{"Error":[]},"NullError":{"TypeError":[],"Error":[]},"JsNoSuchMethodError":{"Error":[]},"UnknownJsTypeError":{"Error":[]},"_StackTrace":{"StackTrace":[]},"Closure":{"Function":[]},"Closure0Args":{"Function":[]},"Closure2Args":{"Function":[]},"TearOffClosure":{"Function":[]},"StaticClosure":{"Function":[]},"BoundClosure":{"Function":[]},"_CyclicInitializationError":{"Error":[]},"RuntimeError":{"Error":[]},"_Error":{"Error":[]},"_TypeError":{"TypeError":[],"Error":[]},"_Future":{"Future":["1"]},"AsyncError":{"Error":[]},"_Zone":{"Zone":[]},"_RootZone":{"_Zone":[],"Zone":[]},"AssertionError":{"Error":[]},"TypeError":{"Error":[]},"ArgumentError":{"Error":[]},"RangeError":{"Error":[]},"IndexError":{"Error":[]},"UnsupportedError":{"Error":[]},"ConcurrentModificationError":{"Error":[]},"OutOfMemoryError":{"Error":[]},"StackOverflowError":{"Error":[]},"_StringStackTrace":{"StackTrace":[]}}'));
  var string$ = {
    Error_: "Error handler must accept one Object or one Object and a StackTrace as arguments, and return a value of the returned future's type"
  };
  var type$ = (function rtii() {
    var findType = A.findType;
    return {
      AsyncError: findType("AsyncError"),
      Error: findType("Error"),
      Function: findType("Function"),
      Future_dynamic: findType("Future<@>"),
      JSArray_String: findType("JSArray<String>"),
      JSArray_dynamic: findType("JSArray<@>"),
      JSNull: findType("JSNull"),
      JavaScriptFunction: findType("JavaScriptFunction"),
      Null: findType("Null"),
      Object: findType("Object"),
      Record: findType("Record"),
      StackTrace: findType("StackTrace"),
      String: findType("String"),
      TrustedGetRuntimeType: findType("TrustedGetRuntimeType"),
      TypeError: findType("TypeError"),
      UnknownJavaScriptObject: findType("UnknownJavaScriptObject"),
      _Future_dynamic: findType("_Future<@>"),
      bool: findType("bool"),
      bool_Function_Object: findType("bool(Object)"),
      double: findType("double"),
      dynamic: findType("@"),
      dynamic_Function: findType("@()"),
      dynamic_Function_Object: findType("@(Object)"),
      dynamic_Function_Object_StackTrace: findType("@(Object,StackTrace)"),
      int: findType("int"),
      legacy_Never: findType("0&*"),
      legacy_Object: findType("Object*"),
      nullable_Future_Null: findType("Future<Null>?"),
      nullable_Object: findType("Object?"),
      nullable__FutureListener_dynamic_dynamic: findType("_FutureListener<@,@>?"),
      num: findType("num"),
      void: findType("~"),
      void_Function: findType("~()")
    };
  })();
  (function constants() {
    B.Interceptor_methods = J.Interceptor.prototype;
    B.JSArray_methods = J.JSArray.prototype;
    B.JSInt_methods = J.JSInt.prototype;
    B.JSString_methods = J.JSString.prototype;
    B.JavaScriptObject_methods = J.JavaScriptObject.prototype;
    B.C_JS_CONST = function getTagFallback(o) {
      var s = Object.prototype.toString.call(o);
      return s.substring(8, s.length - 1);
    };
    B.C_OutOfMemoryError = new A.OutOfMemoryError();
    B.C__RootZone = new A._RootZone();
    B.C__StringStackTrace = new A._StringStackTrace();
    B.Duration_0 = new A.Duration(0);
  })();
  (function staticFields() {
    $.toStringVisiting = A._setArrayType([], A.findType("JSArray<Object>"));
    $.BoundClosure__receiverFieldNameCache = null;
    $.BoundClosure__interceptorFieldNameCache = null;
    $._nextCallback = null;
    $._lastCallback = null;
    $._lastPriorityCallback = null;
    $._isInCallbackLoop = false;
    $.Zone__current = B.C__RootZone;
  })();
  (function lazyInitializers() {
    var _lazyFinal = hunkHelpers.lazyFinal;
    _lazyFinal($, "TypeErrorDecoder_noSuchMethodPattern", "$get$TypeErrorDecoder_noSuchMethodPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({
      toString: function () {
        return "$receiver$";
      }
    })));
    _lazyFinal($, "TypeErrorDecoder_notClosurePattern", "$get$TypeErrorDecoder_notClosurePattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn({
      $method$: null,
      toString: function () {
        return "$receiver$";
      }
    })));
    _lazyFinal($, "TypeErrorDecoder_nullCallPattern", "$get$TypeErrorDecoder_nullCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(null)));
    _lazyFinal($, "TypeErrorDecoder_nullLiteralCallPattern", "$get$TypeErrorDecoder_nullLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function () {
      var $argumentsExpr$ = "$arguments$";
      try {
        null.$method$($argumentsExpr$);
      } catch (e) {
        return e.message;
      }
    }()));
    _lazyFinal($, "TypeErrorDecoder_undefinedCallPattern", "$get$TypeErrorDecoder_undefinedCallPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokeCallErrorOn(void 0)));
    _lazyFinal($, "TypeErrorDecoder_undefinedLiteralCallPattern", "$get$TypeErrorDecoder_undefinedLiteralCallPattern", () => A.TypeErrorDecoder_extractPattern(function () {
      var $argumentsExpr$ = "$arguments$";
      try {
        (void 0).$method$($argumentsExpr$);
      } catch (e) {
        return e.message;
      }
    }()));
    _lazyFinal($, "TypeErrorDecoder_nullPropertyPattern", "$get$TypeErrorDecoder_nullPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(null)));
    _lazyFinal($, "TypeErrorDecoder_nullLiteralPropertyPattern", "$get$TypeErrorDecoder_nullLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function () {
      try {
        null.$method$;
      } catch (e) {
        return e.message;
      }
    }()));
    _lazyFinal($, "TypeErrorDecoder_undefinedPropertyPattern", "$get$TypeErrorDecoder_undefinedPropertyPattern", () => A.TypeErrorDecoder_extractPattern(A.TypeErrorDecoder_provokePropertyErrorOn(void 0)));
    _lazyFinal($, "TypeErrorDecoder_undefinedLiteralPropertyPattern", "$get$TypeErrorDecoder_undefinedLiteralPropertyPattern", () => A.TypeErrorDecoder_extractPattern(function () {
      try {
        (void 0).$method$;
      } catch (e) {
        return e.message;
      }
    }()));
    _lazyFinal($, "_AsyncRun__scheduleImmediateClosure", "$get$_AsyncRun__scheduleImmediateClosure", () => A._AsyncRun__initializeScheduleImmediate());
  })();
  (function nativeSupport() {
    hunkHelpers.setOrUpdateInterceptorsByTag({});
    hunkHelpers.setOrUpdateLeafTags({});
  })();
  Function.prototype.call$1$1 = function (a) {
    return this(a);
  };
  Function.prototype.call$0 = function () {
    return this();
  };
  Function.prototype.call$1 = function (a) {
    return this(a);
  };
  Function.prototype.call$2 = function (a, b) {
    return this(a, b);
  };
  Function.prototype.call$3 = function (a, b, c) {
    return this(a, b, c);
  };
  Function.prototype.call$4 = function (a, b, c, d) {
    return this(a, b, c, d);
  };
  convertAllToFastObject(holders);
  convertToFastObject($);
  (function (callback) {
    if (typeof document === "undefined") {
      callback(null);
      return;
    }
    if (typeof document.currentScript != "undefined") {
      callback(document.currentScript);
      return;
    }
    var scripts = document.scripts;
    function onLoad(event) {
      for (var i = 0; i < scripts.length; ++i) {
        scripts[i].removeEventListener("load", onLoad, false);
      }
      callback(event.target);
    }
    for (var i = 0; i < scripts.length; ++i) {
      scripts[i].addEventListener("load", onLoad, false);
    }
  })(function (currentScript) {
    init.currentScript = currentScript;
    var callMain = A.main;
    if (typeof dartMainRunner === "function") {
      dartMainRunner(callMain, []);
    } else {
      callMain([]);
    }
  });
})();

//# sourceMappingURL=out.js.map