// Generated by dart2js (full emitter, strong), the Dart to JavaScript compiler version: 2.0.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):
//    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.
//
// defaultPackagesBase:
//    Override the location where `package:` uris are resolved from. By default
//    they are resolved under "packages/" from the current window location.
(function() {
  // /* ::norenaming:: */
  var supportsDirectProtoAccess = function() {
    var cls = function() {
    };
    cls.prototype = {p: {}};
    var object = new cls();
    if (!(object.__proto__ && object.__proto__.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 map(x) {
    x = Object.create(null);
    x.x = 0;
    delete x.x;
    return x;
  }
  // The global objects start as so-called "slow objects". For V8, this
  // means that it won't try to make map transitions as we add properties
  // to these objects. Later on, we attempt to turn these objects into
  // fast objects by calling "convertToFastObject" (see
  // [emitConvertToFastObjectFunction]).
  var A = map();
  var B = map();
  var C = map();
  var D = map();
  var E = map();
  var F = map();
  var G = map();
  var H = map();
  var J = map();
  var K = map();
  var L = map();
  var M = map();
  var N = map();
  var O = map();
  var P = map();
  var Q = map();
  var R = map();
  var S = map();
  var T = map();
  var U = map();
  var V = map();
  var W = map();
  var X = map();
  var Y = map();
  var Z = map();
  function Isolate() {
  }
  init();
  // Constructors are generated at runtime.
  function setupProgram(programData, metadataOffset, typesOffset) {
    "use strict";
    function generateAccessor(fieldDescriptor, accessors, cls) {
      var fieldInformation = fieldDescriptor.split("-");
      var field = fieldInformation[0];
      var len = field.length;
      var code = field.charCodeAt(len - 1);
      var reflectable;
      if (fieldInformation.length > 1)
        reflectable = true;
      else
        reflectable = false;
      code = code >= 60 && code <= 64 ? code - 59 : code >= 123 && code <= 126 ? code - 117 : code >= 37 && code <= 43 ? code - 27 : 0;
      if (code) {
        var getterCode = code & 3;
        var setterCode = code >> 2;
        var accessorName = field = field.substring(0, len - 1);
        var divider = field.indexOf(":");
        if (divider > 0) {
          accessorName = field.substring(0, divider);
          field = field.substring(divider + 1);
        }
        if (getterCode) {
          var args = getterCode & 2 ? "receiver" : "";
          var receiver = getterCode & 1 ? "this" : "receiver";
          var body = "return " + receiver + "." + field;
          var property = cls + ".prototype.get$" + accessorName + "=";
          var fn = "function(" + args + "){" + body + "}";
          if (reflectable)
            accessors.push(property + "$reflectable(" + fn + ");\n");
          else
            accessors.push(property + fn + ";\n");
        }
        if (setterCode) {
          var args = setterCode & 2 ? "receiver, value" : "value";
          var receiver = setterCode & 1 ? "this" : "receiver";
          var body = receiver + "." + field + " = value";
          var property = cls + ".prototype.set$" + accessorName + "=";
          var fn = "function(" + args + "){" + body + "}";
          if (reflectable)
            accessors.push(property + "$reflectable(" + fn + ");\n");
          else
            accessors.push(property + fn + ";\n");
        }
      }
      return field;
    }
    function defineClass(name, fields) {
      var accessors = [];
      var str = "function " + name + "(";
      var comma = "", body = "";
      for (var i = 0; i < fields.length; i++) {
        var fieldDescriptor = fields[i];
        if (fieldDescriptor.charCodeAt(0) == 48) {
          fieldDescriptor = fieldDescriptor.substring(1);
          var field = generateAccessor(fieldDescriptor, accessors, name);
          body += "this." + field + " = null;\n";
        } else {
          var field = generateAccessor(fieldDescriptor, accessors, name);
          var parameter = "p_" + field;
          str += comma;
          comma = ", ";
          str += parameter;
          body += "this." + field + " = " + parameter + ";\n";
        }
      }
      if (supportsDirectProtoAccess)
        body += "this." + "$deferredAction" + "();";
      str += ") {\n" + body + "}\n";
      str += name + ".builtin$cls=\"" + name + "\";\n";
      str += "$desc=$collectedClasses." + name + "[1];\n";
      str += name + ".prototype = $desc;\n";
      if (typeof defineClass.name != "string")
        str += name + ".name=\"" + name + "\";\n";
      str += accessors.join("");
      return str;
    }
    var inheritFrom = supportsDirectProtoAccess ? function(constructor, superConstructor) {
      var prototype = constructor.prototype;
      prototype.__proto__ = superConstructor.prototype;
      prototype.constructor = constructor;
      prototype["$is" + constructor.name] = constructor;
      return convertToFastObject(prototype);
    } : function() {
      function tmp() {
      }
      return function(constructor, superConstructor) {
        tmp.prototype = superConstructor.prototype;
        var object = new tmp();
        convertToSlowObject(object);
        var properties = constructor.prototype;
        var members = Object.keys(properties);
        for (var i = 0; i < members.length; i++) {
          var member = members[i];
          object[member] = properties[member];
        }
        object["$is" + constructor.name] = constructor;
        object.constructor = constructor;
        constructor.prototype = object;
        return object;
      };
    }();
    function finishClasses(processedClasses) {
      var allClasses = init.allClasses;
      processedClasses.combinedConstructorFunction += "return [\n" + processedClasses.constructorsList.join(",\n  ") + "\n]";
      var constructors = new Function("$collectedClasses", processedClasses.combinedConstructorFunction)(processedClasses.collected);
      processedClasses.combinedConstructorFunction = null;
      for (var i = 0; i < constructors.length; i++) {
        var constructor = constructors[i];
        var cls = constructor.name;
        var desc = processedClasses.collected[cls];
        var globalObject = desc[0];
        desc = desc[1];
        allClasses[cls] = constructor;
        globalObject[cls] = constructor;
      }
      constructors = null;
      var finishedClasses = init.finishedClasses;
      function finishClass(cls) {
        if (finishedClasses[cls])
          return;
        finishedClasses[cls] = true;
        var superclass = processedClasses.pending[cls];
        if (!superclass || typeof superclass != "string") {
          var constructor = allClasses[cls];
          var prototype = constructor.prototype;
          prototype.constructor = constructor;
          prototype.$isObject = constructor;
          prototype.$deferredAction = function() {
          };
          return;
        }
        finishClass(superclass);
        var superConstructor = allClasses[superclass];
        if (!superConstructor)
          superConstructor = existingIsolateProperties[superclass];
        var constructor = allClasses[cls];
        var prototype = inheritFrom(constructor, superConstructor);
        if (prototype.$isInterceptor)
          prototype.$deferredAction();
      }
      var properties = Object.keys(processedClasses.pending);
      for (var i = 0; i < properties.length; i++)
        finishClass(properties[i]);
    }
    function finishAddStubsHelper() {
      var prototype = this;
      while (!prototype.hasOwnProperty("$deferredAction"))
        prototype = prototype.__proto__;
      delete prototype.$deferredAction;
      var properties = Object.keys(prototype);
      for (var index = 0; index < properties.length; index++) {
        var property = properties[index];
        var firstChar = property.charCodeAt(0);
        var elem;
        if (property !== "^" && property !== "$reflectable" && firstChar !== 43 && firstChar !== 42 && (elem = prototype[property]) != null && elem.constructor === Array && property !== "<>")
          addStubs(prototype, elem, property, false, []);
      }
      convertToFastObject(prototype);
      prototype = prototype.__proto__;
      prototype.$deferredAction();
    }
    function processClassData(cls, descriptor, processedClasses) {
      descriptor = convertToSlowObject(descriptor);
      var previousProperty;
      var properties = Object.keys(descriptor);
      var hasDeferredWork = false;
      var shouldDeferWork = supportsDirectProtoAccess && cls != "Object";
      for (var i = 0; i < properties.length; i++) {
        var property = properties[i];
        var firstChar = property.charCodeAt(0);
        if (property === "static") {
          processStatics(init.statics[cls] = descriptor.static, processedClasses);
          delete descriptor.static;
        } else if (firstChar === 43) {
          mangledNames[previousProperty] = property.substring(1);
          var flag = descriptor[property];
          if (flag > 0)
            descriptor[previousProperty].$reflectable = flag;
        } else if (firstChar === 42) {
          descriptor[previousProperty].$defaultValues = descriptor[property];
          var optionalMethods = descriptor.$methodsWithOptionalArguments;
          if (!optionalMethods)
            descriptor.$methodsWithOptionalArguments = optionalMethods = {};
          optionalMethods[property] = previousProperty;
        } else {
          var elem = descriptor[property];
          if (property !== "^" && elem != null && elem.constructor === Array && property !== "<>")
            if (shouldDeferWork)
              hasDeferredWork = true;
            else
              addStubs(descriptor, elem, property, false, []);
          else
            previousProperty = property;
        }
      }
      if (hasDeferredWork)
        descriptor.$deferredAction = finishAddStubsHelper;
      var classData = descriptor["^"], split, supr, fields = classData;
      var s = fields.split(";");
      fields = s[1] ? s[1].split(",") : [];
      supr = s[0];
      split = supr.split(":");
      if (split.length == 2) {
        supr = split[0];
        var functionSignature = split[1];
        if (functionSignature)
          descriptor.$signature = function(s) {
            return function() {
              return init.types[s];
            };
          }(functionSignature);
      }
      if (supr)
        processedClasses.pending[cls] = supr;
      processedClasses.combinedConstructorFunction += defineClass(cls, fields);
      processedClasses.constructorsList.push(cls);
      processedClasses.collected[cls] = [globalObject, descriptor];
      classes.push(cls);
    }
    function processStatics(descriptor, processedClasses) {
      var properties = Object.keys(descriptor);
      for (var i = 0; i < properties.length; i++) {
        var property = properties[i];
        if (property === "^")
          continue;
        var element = descriptor[property];
        var firstChar = property.charCodeAt(0);
        var previousProperty;
        if (firstChar === 43) {
          mangledGlobalNames[previousProperty] = property.substring(1);
          var flag = descriptor[property];
          if (flag > 0)
            descriptor[previousProperty].$reflectable = flag;
          if (element && element.length)
            init.typeInformation[previousProperty] = element;
        } else if (firstChar === 42) {
          globalObject[previousProperty].$defaultValues = element;
          var optionalMethods = descriptor.$methodsWithOptionalArguments;
          if (!optionalMethods)
            descriptor.$methodsWithOptionalArguments = optionalMethods = {};
          optionalMethods[property] = previousProperty;
        } else if (typeof element === "function") {
          globalObject[previousProperty = property] = element;
          functions.push(property);
        } else if (element.constructor === Array) {
        } else {
          previousProperty = property;
          processClassData(property, element, processedClasses);
        }
      }
    }
    var functionCounter = 0;
    if (!init.libraries)
      init.libraries = [];
    if (!init.mangledNames)
      init.mangledNames = map();
    if (!init.mangledGlobalNames)
      init.mangledGlobalNames = map();
    if (!init.statics)
      init.statics = map();
    if (!init.typeInformation)
      init.typeInformation = map();
    var libraries = init.libraries;
    var mangledNames = init.mangledNames;
    var mangledGlobalNames = init.mangledGlobalNames;
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var length = programData.length;
    var processedClasses = map();
    processedClasses.collected = map();
    processedClasses.pending = map();
    processedClasses.constructorsList = [];
    processedClasses.combinedConstructorFunction = "function $reflectable(fn){fn.$reflectable=1;return fn};\n" + "var $desc;\n";
    for (var i = 0; i < length; i++) {
      var data = programData[i];
      var name = data[0];
      var uri = data[1];
      var metadata = data[2];
      var globalObject = data[3];
      var descriptor = data[4];
      var isRoot = !!data[5];
      var fields = descriptor && descriptor["^"];
      if (fields instanceof Array)
        fields = fields[0];
      var classes = [];
      var functions = [];
      processStatics(descriptor, processedClasses);
      libraries.push([name, uri, classes, functions, metadata, fields, isRoot, globalObject]);
    }
    finishClasses(processedClasses);
  }
  Isolate.functionThatReturnsNull = function() {
  };
  var dart = [["_foreign_helper", "dart:_foreign_helper",, H, {
    "^": "",
    JS_CONST: {
      "^": "Object;code"
    }
  }], ["_interceptors", "dart:_interceptors",, J, {
    "^": "",
    getInterceptor: function(object) {
      return void 0;
    },
    Interceptor: {
      "^": "Object;",
      toString$0: function(receiver) {
        return "Instance of '" + H.Primitives_objectTypeName(receiver) + "'";
      }
    },
    JSBool: {
      "^": "Interceptor;",
      toString$0: function(receiver) {
        return String(receiver);
      },
      $isbool: 1
    },
    JSNull: {
      "^": "Interceptor;",
      toString$0: function(receiver) {
        return "null";
      }
    },
    JSArray: {
      "^": "Interceptor;$ti",
      add$1: function(receiver, value) {
        H.assertSubtypeOfRuntimeType(value, H.getTypeArgumentByIndex(receiver, 0));
        if (!!receiver.fixed$length)
          H.throwExpression(P.UnsupportedError$("add"));
        receiver.push(value);
      },
      toString$0: function(receiver) {
        return P.IterableBase_iterableToFullString(receiver, "[", "]");
      },
      get$length: function(receiver) {
        return receiver.length;
      },
      $isIterable: 1,
      $isList: 1,
      static: {
        JSArray_JSArray$markFixed: function(allocation, $E) {
          return J.JSArray_markFixedList(H.setRuntimeTypeInfo(allocation, [$E]));
        },
        JSArray_markFixedList: function(list) {
          H.listTypeCheck(list);
          list.fixed$length = Array;
          return list;
        }
      }
    },
    JSUnmodifiableArray: {
      "^": "JSArray;$ti"
    },
    ArrayIterator: {
      "^": "Object;_iterable,_length,_index,0_current,$ti",
      moveNext$0: function() {
        var t1, $length, t2;
        t1 = this._iterable;
        $length = t1.length;
        if (this._length !== $length)
          throw H.wrapException(H.throwConcurrentModificationError(t1));
        t2 = this._index;
        if (t2 >= $length) {
          this._current = null;
          return false;
        }
        this._current = t1[t2];
        this._index = t2 + 1;
        return true;
      }
    },
    JSNumber: {
      "^": "Interceptor;",
      toString$0: function(receiver) {
        if (receiver === 0 && 1 / receiver < 0)
          return "-0.0";
        else
          return "" + receiver;
      },
      $mod: function(receiver, other) {
        var result;
        if (typeof other !== "number")
          throw H.wrapException(H.argumentErrorValue(other));
        result = receiver % other;
        if (result === 0)
          return 0;
        if (result > 0)
          return result;
        if (other < 0)
          return result - other;
        else
          return result + other;
      },
      $isnum: 1
    },
    JSInt: {
      "^": "JSNumber;",
      $isint: 1
    },
    JSDouble: {
      "^": "JSNumber;"
    },
    JSString: {
      "^": "Interceptor;",
      _codeUnitAt$1: function(receiver, index) {
        if (index >= receiver.length)
          throw H.wrapException(H.diagnoseIndexError(receiver, index));
        return receiver.charCodeAt(index);
      },
      $add: function(receiver, other) {
        H.stringTypeCheck(other);
        if (typeof other !== "string")
          throw H.wrapException(P.ArgumentError$value(other, null, null));
        return receiver + other;
      },
      substring$2: function(receiver, startIndex, endIndex) {
        if (endIndex == null)
          endIndex = receiver.length;
        if (startIndex > endIndex)
          throw H.wrapException(P.RangeError$value(startIndex, null, null));
        if (endIndex > receiver.length)
          throw H.wrapException(P.RangeError$value(endIndex, null, null));
        return receiver.substring(startIndex, endIndex);
      },
      substring$1: function($receiver, startIndex) {
        return this.substring$2($receiver, startIndex, null);
      },
      toString$0: function(receiver) {
        return receiver;
      },
      get$length: function(receiver) {
        return receiver.length;
      },
      $isString: 1
    }
  }], ["_js_helper", "dart:_js_helper",, H, {
    "^": "",
    getType: function(index) {
      return init.types[H.intTypeCheck(index)];
    },
    S: function(value) {
      var res;
      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";
      res = J.toString$0$(value);
      if (typeof res !== "string")
        throw H.wrapException(H.argumentErrorValue(value));
      return res;
    },
    Primitives_parseInt: function(source, radix) {
      H.checkString(source);
    },
    Primitives_objectTypeName: function(object) {
      var interceptor, interceptorConstructor, interceptorConstructorName, $name, dispatchName, objectConstructor, match, decompiledName, t1;
      interceptor = J.getInterceptor(object);
      interceptorConstructor = interceptor.constructor;
      if (typeof interceptorConstructor == "function") {
        interceptorConstructorName = interceptorConstructor.name;
        $name = typeof interceptorConstructorName === "string" ? interceptorConstructorName : null;
      } else
        $name = null;
      if ($name == null || interceptor === C.Interceptor_methods || false) {
        dispatchName = C.JS_CONST_u2C(object);
        if (dispatchName === "Object") {
          objectConstructor = object.constructor;
          if (typeof objectConstructor == "function") {
            match = String(objectConstructor).match(/^\s*function\s*([\w$]*)\s*\(/);
            decompiledName = match == null ? null : match[1];
            if (typeof decompiledName === "string" && /^\w+$/.test(decompiledName))
              $name = decompiledName;
          }
          if ($name == null)
            $name = dispatchName;
        } else
          $name = dispatchName;
      }
      $name = $name;
      if ($name.length > 1 && C.JSString_methods._codeUnitAt$1($name, 0) === 36)
        $name = C.JSString_methods.substring$1($name, 1);
      t1 = H.joinArgumentsV2(H.listTypeCheck(H.getRuntimeTypeInfo(object)), 0, null);
      return function(str, names) {
        return str.replace(/[^<,> ]+/g, function(m) {
          return names[m] || m;
        });
      }($name + t1, init.mangledGlobalNames);
    },
    iae: function(argument) {
      throw H.wrapException(H.argumentErrorValue(argument));
    },
    ioore: function(receiver, index) {
      if (receiver == null)
        J.get$length$as(receiver);
      throw H.wrapException(H.diagnoseIndexError(receiver, index));
    },
    diagnoseIndexError: function(indexable, index) {
      var $length;
      if (typeof index !== "number" || Math.floor(index) !== index)
        return new P.ArgumentError(true, index, "index", null);
      $length = J.get$length$as(indexable);
      if (index < 0 || index >= $length)
        return P.IndexError$(index, indexable, "index", null, $length);
      return P.RangeError$value(index, "index", null);
    },
    argumentErrorValue: function(object) {
      return new P.ArgumentError(true, object, null, null);
    },
    checkString: function(value) {
      return value;
    },
    wrapException: function(ex) {
      var wrapper;
      if (ex == null)
        ex = new P.NullThrownError();
      wrapper = new Error();
      wrapper.dartException = ex;
      if ("defineProperty" in Object) {
        Object.defineProperty(wrapper, "message", {get: H.toStringWrapper});
        wrapper.name = "";
      } else
        wrapper.toString = H.toStringWrapper;
      return wrapper;
    },
    toStringWrapper: function() {
      return J.toString$0$(this.dartException);
    },
    throwExpression: function(ex) {
      throw H.wrapException(ex);
    },
    throwConcurrentModificationError: function(collection) {
      throw H.wrapException(P.ConcurrentModificationError$(collection));
    },
    Closure_fromTearOff: function(receiver, functions, applyTrampolineIndex, reflectionInfo, isStatic, jsArguments, propertyName) {
      var $function, callName, functionType, $prototype, $constructor, t1, isIntercepted, trampoline, signatureFunction, getReceiver, applyTrampoline, i, stub, stubCallName;
      $function = functions[0];
      callName = $function.$callName;
      if (!!J.getInterceptor(reflectionInfo).$isList) {
        $function.$reflectionInfo = reflectionInfo;
        functionType = H.ReflectionInfo_ReflectionInfo($function).functionType;
      } else
        functionType = reflectionInfo;
      $prototype = isStatic ? Object.create(new H.StaticClosure().constructor.prototype) : Object.create(new H.BoundClosure(null, null, null, null).constructor.prototype);
      $prototype.$initialize = $prototype.constructor;
      if (isStatic)
        $constructor = function() {
          this.$initialize();
        };
      else {
        t1 = $.Closure_functionCounter;
        if (typeof t1 !== "number")
          return t1.$add();
        $.Closure_functionCounter = t1 + 1;
        t1 = new Function("a,b,c,d" + t1, "this.$initialize(a,b,c,d" + t1 + ")");
        $constructor = t1;
      }
      $prototype.constructor = $constructor;
      $constructor.prototype = $prototype;
      if (!isStatic) {
        isIntercepted = jsArguments.length == 1 && true;
        trampoline = H.Closure_forwardCallTo(receiver, $function, isIntercepted);
        trampoline.$reflectionInfo = reflectionInfo;
      } else {
        $prototype.$static_name = propertyName;
        trampoline = $function;
        isIntercepted = false;
      }
      if (typeof functionType == "number")
        signatureFunction = function(getType, t) {
          return function() {
            return getType(t);
          };
        }(H.getType, functionType);
      else if (typeof functionType == "function")
        if (isStatic)
          signatureFunction = functionType;
        else {
          getReceiver = isIntercepted ? H.BoundClosure_receiverOf : H.BoundClosure_selfOf;
          signatureFunction = function(f, r) {
            return function() {
              return f.apply({$receiver: r(this)}, arguments);
            };
          }(functionType, getReceiver);
        }
      else
        throw H.wrapException("Error in reflectionInfo.");
      $prototype.$signature = signatureFunction;
      $prototype[callName] = trampoline;
      for (t1 = functions.length, applyTrampoline = trampoline, i = 1; i < t1; ++i) {
        stub = functions[i];
        stubCallName = stub.$callName;
        if (stubCallName != null) {
          stub = isStatic ? stub : H.Closure_forwardCallTo(receiver, stub, isIntercepted);
          $prototype[stubCallName] = stub;
        }
        if (i === applyTrampolineIndex) {
          stub.$reflectionInfo = reflectionInfo;
          applyTrampoline = stub;
        }
      }
      $prototype["call*"] = applyTrampoline;
      $prototype.$requiredArgCount = $function.$requiredArgCount;
      $prototype.$defaultValues = $function.$defaultValues;
      return $constructor;
    },
    Closure_cspForwardCall: function(arity, isSuperCall, stubName, $function) {
      var getSelf = H.BoundClosure_selfOf;
      switch (isSuperCall ? -1 : arity) {
        case 0:
          return function(n, S) {
            return function() {
              return S(this)[n]();
            };
          }(stubName, getSelf);
        case 1:
          return function(n, S) {
            return function(a) {
              return S(this)[n](a);
            };
          }(stubName, getSelf);
        case 2:
          return function(n, S) {
            return function(a, b) {
              return S(this)[n](a, b);
            };
          }(stubName, getSelf);
        case 3:
          return function(n, S) {
            return function(a, b, c) {
              return S(this)[n](a, b, c);
            };
          }(stubName, getSelf);
        case 4:
          return function(n, S) {
            return function(a, b, c, d) {
              return S(this)[n](a, b, c, d);
            };
          }(stubName, getSelf);
        case 5:
          return function(n, S) {
            return function(a, b, c, d, e) {
              return S(this)[n](a, b, c, d, e);
            };
          }(stubName, getSelf);
        default:
          return function(f, s) {
            return function() {
              return f.apply(s(this), arguments);
            };
          }($function, getSelf);
      }
    },
    Closure_forwardCallTo: function(receiver, $function, isIntercepted) {
      var stubName, arity, lookedUpFunction, t1, t2, selfName, $arguments;
      if (isIntercepted)
        return H.Closure_forwardInterceptedCallTo(receiver, $function);
      stubName = $function.$stubName;
      arity = $function.length;
      lookedUpFunction = receiver[stubName];
      t1 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction;
      t2 = !t1 || arity >= 27;
      if (t2)
        return H.Closure_cspForwardCall(arity, !t1, stubName, $function);
      if (arity === 0) {
        t1 = $.Closure_functionCounter;
        if (typeof t1 !== "number")
          return t1.$add();
        $.Closure_functionCounter = t1 + 1;
        selfName = "self" + t1;
        t1 = "return function(){var " + selfName + " = this.";
        t2 = $.BoundClosure_selfFieldNameCache;
        if (t2 == null) {
          t2 = H.BoundClosure_computeFieldNamed("self");
          $.BoundClosure_selfFieldNameCache = t2;
        }
        return new Function(t1 + H.S(t2) + ";return " + selfName + "." + H.S(stubName) + "();}")();
      }
      $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(",");
      t1 = $.Closure_functionCounter;
      if (typeof t1 !== "number")
        return t1.$add();
      $.Closure_functionCounter = t1 + 1;
      $arguments += t1;
      t1 = "return function(" + $arguments + "){return this.";
      t2 = $.BoundClosure_selfFieldNameCache;
      if (t2 == null) {
        t2 = H.BoundClosure_computeFieldNamed("self");
        $.BoundClosure_selfFieldNameCache = t2;
      }
      return new Function(t1 + H.S(t2) + "." + H.S(stubName) + "(" + $arguments + ");}")();
    },
    Closure_cspForwardInterceptedCall: function(arity, isSuperCall, $name, $function) {
      var getSelf, getReceiver;
      getSelf = H.BoundClosure_selfOf;
      getReceiver = H.BoundClosure_receiverOf;
      switch (isSuperCall ? -1 : arity) {
        case 0:
          throw H.wrapException(new H.RuntimeError("Intercepted function with no arguments."));
        case 1:
          return function(n, s, r) {
            return function() {
              return s(this)[n](r(this));
            };
          }($name, getSelf, getReceiver);
        case 2:
          return function(n, s, r) {
            return function(a) {
              return s(this)[n](r(this), a);
            };
          }($name, getSelf, getReceiver);
        case 3:
          return function(n, s, r) {
            return function(a, b) {
              return s(this)[n](r(this), a, b);
            };
          }($name, getSelf, getReceiver);
        case 4:
          return function(n, s, r) {
            return function(a, b, c) {
              return s(this)[n](r(this), a, b, c);
            };
          }($name, getSelf, getReceiver);
        case 5:
          return function(n, s, r) {
            return function(a, b, c, d) {
              return s(this)[n](r(this), a, b, c, d);
            };
          }($name, getSelf, getReceiver);
        case 6:
          return function(n, s, r) {
            return function(a, b, c, d, e) {
              return s(this)[n](r(this), a, b, c, d, e);
            };
          }($name, getSelf, getReceiver);
        default:
          return function(f, s, r, a) {
            return function() {
              a = [r(this)];
              Array.prototype.push.apply(a, arguments);
              return f.apply(s(this), a);
            };
          }($function, getSelf, getReceiver);
      }
    },
    Closure_forwardInterceptedCallTo: function(receiver, $function) {
      var t1, t2, stubName, arity, lookedUpFunction, t3, t4, $arguments;
      t1 = $.BoundClosure_selfFieldNameCache;
      if (t1 == null) {
        t1 = H.BoundClosure_computeFieldNamed("self");
        $.BoundClosure_selfFieldNameCache = t1;
      }
      t2 = $.BoundClosure_receiverFieldNameCache;
      if (t2 == null) {
        t2 = H.BoundClosure_computeFieldNamed("receiver");
        $.BoundClosure_receiverFieldNameCache = t2;
      }
      stubName = $function.$stubName;
      arity = $function.length;
      lookedUpFunction = receiver[stubName];
      t3 = $function == null ? lookedUpFunction == null : $function === lookedUpFunction;
      t4 = !t3 || arity >= 28;
      if (t4)
        return H.Closure_cspForwardInterceptedCall(arity, !t3, stubName, $function);
      if (arity === 1) {
        t1 = "return function(){return this." + H.S(t1) + "." + H.S(stubName) + "(this." + H.S(t2) + ");";
        t2 = $.Closure_functionCounter;
        if (typeof t2 !== "number")
          return t2.$add();
        $.Closure_functionCounter = t2 + 1;
        return new Function(t1 + t2 + "}")();
      }
      $arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity - 1).join(",");
      t1 = "return function(" + $arguments + "){return this." + H.S(t1) + "." + H.S(stubName) + "(this." + H.S(t2) + ", " + $arguments + ");";
      t2 = $.Closure_functionCounter;
      if (typeof t2 !== "number")
        return t2.$add();
      $.Closure_functionCounter = t2 + 1;
      return new Function(t1 + t2 + "}")();
    },
    closureFromTearOff: function(receiver, functions, applyTrampolineIndex, reflectionInfo, isStatic, jsArguments, $name) {
      var t1, t2;
      t1 = J.JSArray_markFixedList(H.listTypeCheck(functions));
      H.intTypeCheck(applyTrampolineIndex);
      t2 = !!J.getInterceptor(reflectionInfo).$isList ? J.JSArray_markFixedList(reflectionInfo) : reflectionInfo;
      return H.Closure_fromTearOff(receiver, t1, applyTrampolineIndex, t2, !!isStatic, jsArguments, $name);
    },
    stringTypeCheck: function(value) {
      if (value == null)
        return value;
      if (typeof value === "string")
        return value;
      throw H.wrapException(H.TypeErrorImplementation$(value, "String"));
    },
    intTypeCheck: function(value) {
      if (value == null)
        return value;
      if (typeof value === "number" && Math.floor(value) === value)
        return value;
      throw H.wrapException(H.TypeErrorImplementation$(value, "int"));
    },
    listTypeCheck: function(value) {
      if (value == null)
        return value;
      if (!!J.getInterceptor(value).$isList)
        return value;
      throw H.wrapException(H.TypeErrorImplementation$(value, "List"));
    },
    extractFunctionTypeObjectFromInternal: function(o) {
      var signature;
      if ("$signature" in o) {
        signature = o.$signature;
        if (typeof signature == "number")
          return init.types[H.intTypeCheck(signature)];
        else
          return o.$signature();
      }
      return;
    },
    functionTypeTest: function(value, functionTypeRti) {
      var functionTypeObject, t1;
      if (value == null)
        return false;
      if (typeof value == "function")
        return true;
      functionTypeObject = H.extractFunctionTypeObjectFromInternal(J.getInterceptor(value));
      if (functionTypeObject == null)
        return false;
      t1 = H.isFunctionSubtypeV2(functionTypeObject, null, functionTypeRti, null);
      return t1;
    },
    _typeDescription: function(value) {
      var functionTypeObject;
      if (value instanceof H.Closure) {
        functionTypeObject = H.extractFunctionTypeObjectFromInternal(J.getInterceptor(value));
        if (functionTypeObject != null)
          return H.runtimeTypeToString(functionTypeObject);
        return "Closure";
      }
      return H.Primitives_objectTypeName(value);
    },
    throwCyclicInit: function(staticName) {
      throw H.wrapException(new P.CyclicInitializationError(H.stringTypeCheck(staticName)));
    },
    setRuntimeTypeInfo: function(target, rti) {
      target.$ti = rti;
      return target;
    },
    getRuntimeTypeInfo: function(target) {
      if (target == null)
        return;
      return target.$ti;
    },
    getTypeArgumentByIndex: function(target, index) {
      var rti;
      H.intTypeCheck(index);
      rti = H.getRuntimeTypeInfo(target);
      return rti == null ? null : rti[index];
    },
    runtimeTypeToString: function(rti) {
      var t1 = H.runtimeTypeToStringV2(rti, null);
      return t1;
    },
    runtimeTypeToStringV2: function(rti, genericContext) {
      var t1, t2;
      H.assertSubtype(genericContext, "$isList", [P.String], "$asList");
      if (rti == null)
        return "dynamic";
      if (rti === -1)
        return "void";
      if (typeof rti === "object" && rti !== null && rti.constructor === Array)
        return rti[0].builtin$cls + H.joinArgumentsV2(rti, 1, genericContext);
      if (typeof rti == "function")
        return rti.builtin$cls;
      if (rti === -2)
        return "dynamic";
      if (typeof rti === "number") {
        H.intTypeCheck(rti);
        if (genericContext == null || rti < 0 || rti >= genericContext.length)
          return "unexpected-generic-index:" + rti;
        t1 = genericContext.length;
        t2 = t1 - rti - 1;
        if (t2 < 0 || t2 >= t1)
          return H.ioore(genericContext, t2);
        return H.S(genericContext[t2]);
      }
      if ('func' in rti)
        return H._functionRtiToStringV2(rti, genericContext);
      if ('futureOr' in rti)
        return "FutureOr<" + H.runtimeTypeToStringV2("type" in rti ? rti.type : null, genericContext) + ">";
      return "unknown-reified-type";
    },
    _functionRtiToStringV2: function(rti, genericContext) {
      var t1, boundsRti, outerContextLength, offset, i, i0, typeParameters, typeSep, t2, boundRti, returnTypeText, $arguments, argumentsText, sep, _i, argument, optionalArguments, namedArguments, t3;
      t1 = [P.String];
      H.assertSubtype(genericContext, "$isList", t1, "$asList");
      if ("bounds" in rti) {
        boundsRti = rti.bounds;
        if (genericContext == null) {
          genericContext = H.setRuntimeTypeInfo([], t1);
          outerContextLength = null;
        } else
          outerContextLength = genericContext.length;
        offset = genericContext.length;
        for (i = boundsRti.length, i0 = i; i0 > 0; --i0)
          C.JSArray_methods.add$1(genericContext, "T" + (offset + i0));
        for (typeParameters = "<", typeSep = "", i0 = 0; i0 < i; ++i0, typeSep = ", ") {
          typeParameters += typeSep;
          t1 = genericContext.length;
          t2 = t1 - i0 - 1;
          if (t2 < 0)
            return H.ioore(genericContext, t2);
          typeParameters = C.JSString_methods.$add(typeParameters, genericContext[t2]);
          boundRti = boundsRti[i0];
          if (boundRti != null && boundRti !== P.Object)
            typeParameters += " extends " + H.runtimeTypeToStringV2(boundRti, genericContext);
        }
        typeParameters += ">";
      } else {
        typeParameters = "";
        outerContextLength = null;
      }
      returnTypeText = !!rti.v ? "void" : H.runtimeTypeToStringV2(rti.ret, genericContext);
      if ("args" in rti) {
        $arguments = rti.args;
        for (t1 = $arguments.length, argumentsText = "", sep = "", _i = 0; _i < t1; ++_i, sep = ", ") {
          argument = $arguments[_i];
          argumentsText = argumentsText + sep + H.runtimeTypeToStringV2(argument, genericContext);
        }
      } else {
        argumentsText = "";
        sep = "";
      }
      if ("opt" in rti) {
        optionalArguments = rti.opt;
        argumentsText += sep + "[";
        for (t1 = optionalArguments.length, sep = "", _i = 0; _i < t1; ++_i, sep = ", ") {
          argument = optionalArguments[_i];
          argumentsText = argumentsText + sep + H.runtimeTypeToStringV2(argument, genericContext);
        }
        argumentsText += "]";
      }
      if ("named" in rti) {
        namedArguments = rti.named;
        argumentsText += sep + "{";
        for (t1 = H.extractKeys(namedArguments), t2 = t1.length, sep = "", _i = 0; _i < t2; ++_i, sep = ", ") {
          t3 = H.stringTypeCheck(t1[_i]);
          argumentsText = argumentsText + sep + H.runtimeTypeToStringV2(namedArguments[t3], genericContext) + (" " + H.S(t3));
        }
        argumentsText += "}";
      }
      if (outerContextLength != null)
        genericContext.length = outerContextLength;
      return typeParameters + "(" + argumentsText + ") => " + returnTypeText;
    },
    joinArgumentsV2: function(types, startIndex, genericContext) {
      var buffer, index, separator, allDynamic, t1, argument;
      H.assertSubtype(genericContext, "$isList", [P.String], "$asList");
      if (types == null)
        return "";
      buffer = new P.StringBuffer("");
      for (index = startIndex, separator = "", allDynamic = true, t1 = ""; index < types.length; ++index, separator = ", ") {
        buffer._contents = t1 + separator;
        argument = types[index];
        if (argument != null)
          allDynamic = false;
        t1 = buffer._contents += H.runtimeTypeToStringV2(argument, genericContext);
      }
      t1 = "<" + buffer.toString$0(0) + ">";
      return t1;
    },
    substitute: function(substitution, $arguments) {
      if (substitution == null)
        return $arguments;
      substitution = substitution.apply(null, $arguments);
      if (substitution == null)
        return;
      if (typeof substitution === "object" && substitution !== null && substitution.constructor === Array)
        return substitution;
      if (typeof substitution == "function")
        return substitution.apply(null, $arguments);
      return $arguments;
    },
    checkSubtypeV2: function(object, isField, checks, asField) {
      var $arguments, interceptor;
      if (object == null)
        return false;
      $arguments = H.getRuntimeTypeInfo(object);
      interceptor = J.getInterceptor(object);
      if (interceptor[isField] == null)
        return false;
      return H.areSubtypesV2(H.substitute(interceptor[asField], $arguments), null, checks, null);
    },
    assertSubtype: function(object, isField, checks, asField) {
      var t1, t2;
      H.stringTypeCheck(isField);
      H.listTypeCheck(checks);
      H.stringTypeCheck(asField);
      if (object == null)
        return object;
      t1 = H.checkSubtypeV2(object, isField, checks, asField);
      if (t1)
        return object;
      t1 = isField.substring(3);
      t2 = H.joinArgumentsV2(checks, 0, null);
      throw H.wrapException(H.TypeErrorImplementation$(object, function(str, names) {
        return str.replace(/[^<,> ]+/g, function(m) {
          return names[m] || m;
        });
      }(t1 + t2, init.mangledGlobalNames)));
    },
    areSubtypesV2: function(s, sEnv, t, tEnv) {
      var len, i;
      if (t == null)
        return true;
      if (s == null) {
        len = t.length;
        for (i = 0; i < len; ++i)
          if (!H.isSubtypeV2(null, null, t[i], tEnv))
            return false;
        return true;
      }
      len = s.length;
      for (i = 0; i < len; ++i)
        if (!H.isSubtypeV2(s[i], sEnv, t[i], tEnv))
          return false;
      return true;
    },
    isSupertypeOfNullRecursive: function(type) {
      var typeArgument;
      if (typeof type === "number")
        return false;
      if ('futureOr' in type) {
        typeArgument = "type" in type ? type.type : null;
        return type == null || type.builtin$cls === "Object" || type.builtin$cls === "Null" || type === -1 || type === -2 || H.isSupertypeOfNullRecursive(typeArgument);
      }
      return false;
    },
    checkSubtypeOfRuntimeType: function(o, t) {
      var t1, type, rti;
      if (o == null) {
        t1 = t == null || t.builtin$cls === "Object" || t.builtin$cls === "Null" || t === -1 || t === -2 || H.isSupertypeOfNullRecursive(t);
        return t1;
      }
      t1 = t == null || t === -1 || t.builtin$cls === "Object" || t === -2;
      if (t1)
        return true;
      if (typeof t == "object") {
        t1 = 'futureOr' in t;
        if (t1)
          if (H.checkSubtypeOfRuntimeType(o, "type" in t ? t.type : null))
            return true;
        if ('func' in t)
          return H.functionTypeTest(o, t);
      }
      type = J.getInterceptor(o).constructor;
      rti = H.getRuntimeTypeInfo(o);
      if (rti != null) {
        rti = rti.slice();
        rti.splice(0, 0, type);
        type = rti;
      }
      t1 = H.isSubtypeV2(type, null, t, null);
      return t1;
    },
    assertSubtypeOfRuntimeType: function(object, type) {
      if (object != null && !H.checkSubtypeOfRuntimeType(object, type))
        throw H.wrapException(H.TypeErrorImplementation$(object, H.runtimeTypeToString(type)));
      return object;
    },
    isSubtypeV2: function(s, sEnv, t, tEnv) {
      var t1, typeOfS, tTypeArgument, futureSubstitution, futureArguments, t2, typeOfT, typeOfTString, substitution;
      if (s === t)
        return true;
      if (t == null || t === -1 || t.builtin$cls === "Object" || t === -2)
        return true;
      if (s === -2)
        return true;
      if (s == null || s === -1 || s.builtin$cls === "Object" || s === -2) {
        if (typeof t === "number")
          return false;
        if ('futureOr' in t)
          return H.isSubtypeV2(s, sEnv, "type" in t ? t.type : null, tEnv);
        return false;
      }
      if (typeof s === "number")
        return false;
      if (typeof t === "number")
        return false;
      if (s.builtin$cls === "Null")
        return true;
      if ('func' in t)
        return H.isFunctionSubtypeV2(s, sEnv, t, tEnv);
      if ('func' in s)
        return t.builtin$cls === "Function";
      t1 = typeof s === "object" && s !== null && s.constructor === Array;
      typeOfS = t1 ? s[0] : s;
      if ('futureOr' in t) {
        tTypeArgument = "type" in t ? t.type : null;
        if ('futureOr' in s)
          return H.isSubtypeV2("type" in s ? s.type : null, sEnv, tTypeArgument, tEnv);
        else if (H.isSubtypeV2(s, sEnv, tTypeArgument, tEnv))
          return true;
        else {
          if (!('$is' + "Future" in typeOfS.prototype))
            return false;
          futureSubstitution = typeOfS.prototype["$as" + "Future"];
          futureArguments = H.substitute(futureSubstitution, t1 ? s.slice(1) : null);
          return H.isSubtypeV2(typeof futureArguments === "object" && futureArguments !== null && futureArguments.constructor === Array ? futureArguments[0] : null, sEnv, tTypeArgument, tEnv);
        }
      }
      t2 = typeof t === "object" && t !== null && t.constructor === Array;
      typeOfT = t2 ? t[0] : t;
      if (typeOfT !== typeOfS) {
        typeOfTString = H.runtimeTypeToString(typeOfT);
        if (!('$is' + typeOfTString in typeOfS.prototype))
          return false;
        substitution = typeOfS.prototype["$as" + typeOfTString];
      } else
        substitution = null;
      if (!t2)
        return true;
      t1 = t1 ? s.slice(1) : null;
      t2 = t.slice(1);
      return H.areSubtypesV2(H.substitute(substitution, t1), sEnv, t2, tEnv);
    },
    isFunctionSubtypeV2: function(s, sEnv, t, tEnv) {
      var sBounds, tBounds, sParameterTypes, tParameterTypes, sOptionalParameterTypes, tOptionalParameterTypes, sParametersLen, tParametersLen, sOptionalParametersLen, tOptionalParametersLen, pos, tPos, sPos, sNamedParameters, tNamedParameters;
      if (!('func' in s))
        return false;
      if ("bounds" in s) {
        if (!("bounds" in t))
          return false;
        sBounds = s.bounds;
        tBounds = t.bounds;
        if (sBounds.length !== tBounds.length)
          return false;
      } else if ("bounds" in t)
        return false;
      if (!H.isSubtypeV2(s.ret, sEnv, t.ret, tEnv))
        return false;
      sParameterTypes = s.args;
      tParameterTypes = t.args;
      sOptionalParameterTypes = s.opt;
      tOptionalParameterTypes = t.opt;
      sParametersLen = sParameterTypes != null ? sParameterTypes.length : 0;
      tParametersLen = tParameterTypes != null ? tParameterTypes.length : 0;
      sOptionalParametersLen = sOptionalParameterTypes != null ? sOptionalParameterTypes.length : 0;
      tOptionalParametersLen = tOptionalParameterTypes != null ? tOptionalParameterTypes.length : 0;
      if (sParametersLen > tParametersLen)
        return false;
      if (sParametersLen + sOptionalParametersLen < tParametersLen + tOptionalParametersLen)
        return false;
      for (pos = 0; pos < sParametersLen; ++pos)
        if (!H.isSubtypeV2(tParameterTypes[pos], tEnv, sParameterTypes[pos], sEnv))
          return false;
      for (tPos = pos, sPos = 0; tPos < tParametersLen; ++sPos, ++tPos)
        if (!H.isSubtypeV2(tParameterTypes[tPos], tEnv, sOptionalParameterTypes[sPos], sEnv))
          return false;
      for (tPos = 0; tPos < tOptionalParametersLen; ++sPos, ++tPos)
        if (!H.isSubtypeV2(tOptionalParameterTypes[tPos], tEnv, sOptionalParameterTypes[sPos], sEnv))
          return false;
      sNamedParameters = s.named;
      tNamedParameters = t.named;
      if (tNamedParameters == null)
        return true;
      if (sNamedParameters == null)
        return false;
      return H.namedParametersSubtypeCheckV2(sNamedParameters, sEnv, tNamedParameters, tEnv);
    },
    namedParametersSubtypeCheckV2: function(s, sEnv, t, tEnv) {
      var names, t1, i, $name;
      names = Object.getOwnPropertyNames(t);
      for (t1 = names.length, i = 0; i < t1; ++i) {
        $name = names[i];
        if (!Object.hasOwnProperty.call(s, $name))
          return false;
        if (!H.isSubtypeV2(t[$name], tEnv, s[$name], sEnv))
          return false;
      }
      return true;
    },
    ReflectionInfo: {
      "^": "Object;jsFunction,data,isAccessor,requiredParameterCount,optionalParameterCount,areOptionalParametersNamed,functionType,0cachedSortedIndices",
      static: {
        ReflectionInfo_ReflectionInfo: function(jsFunction) {
          var data, requiredParametersInfo, optionalParametersInfo;
          data = jsFunction.$reflectionInfo;
          if (data == null)
            return;
          data = J.JSArray_markFixedList(data);
          requiredParametersInfo = data[0];
          optionalParametersInfo = data[1];
          return new H.ReflectionInfo(jsFunction, data, (requiredParametersInfo & 2) === 2, requiredParametersInfo >> 2, optionalParametersInfo >> 1, (optionalParametersInfo & 1) === 1, data[2]);
        }
      }
    },
    Closure: {
      "^": "Object;",
      toString$0: function(_) {
        return "Closure '" + H.Primitives_objectTypeName(this).trim() + "'";
      },
      get$$call: function() {
        return this;
      },
      get$$call: function() {
        return this;
      }
    },
    TearOffClosure: {
      "^": "Closure;"
    },
    StaticClosure: {
      "^": "TearOffClosure;",
      toString$0: function(_) {
        var $name = this.$static_name;
        if ($name == null)
          return "Closure of unknown static method";
        return "Closure '" + $name + "'";
      }
    },
    BoundClosure: {
      "^": "TearOffClosure;_self,_target,_receiver,_name",
      toString$0: function(_) {
        var receiver = this._receiver;
        if (receiver == null)
          receiver = this._self;
        return "Closure '" + H.S(this._name) + "' of " + ("Instance of '" + H.Primitives_objectTypeName(receiver) + "'");
      },
      static: {
        BoundClosure_selfOf: function(closure) {
          return closure._self;
        },
        BoundClosure_receiverOf: function(closure) {
          return closure._receiver;
        },
        BoundClosure_computeFieldNamed: function(fieldName) {
          var template, names, t1, i, $name;
          template = new H.BoundClosure("self", "target", "receiver", "name");
          names = J.JSArray_markFixedList(Object.getOwnPropertyNames(template));
          for (t1 = names.length, i = 0; i < t1; ++i) {
            $name = names[i];
            if (template[$name] === fieldName)
              return $name;
          }
        }
      }
    },
    TypeErrorImplementation: {
      "^": "Error;message",
      toString$0: function(_) {
        return this.message;
      },
      static: {
        TypeErrorImplementation$: function(value, type) {
          return new H.TypeErrorImplementation("TypeError: " + H.S(P.Error_safeToString(value)) + ": type '" + H._typeDescription(value) + "' is not a subtype of type '" + type + "'");
        }
      }
    },
    RuntimeError: {
      "^": "Error;message",
      toString$0: function(_) {
        return "RuntimeError: " + this.message;
      }
    }
  }], ["dart._js_names", "dart:_js_names",, H, {
    "^": "",
    extractKeys: function(victim) {
      return J.JSArray_JSArray$markFixed(victim ? Object.keys(victim) : [], null);
    }
  }], ["dart2js._js_primitives", "dart:_js_primitives",, H, {
    "^": "",
    printString: function(string) {
      if (typeof dartPrint == "function") {
        dartPrint(string);
        return;
      }
      if (typeof console == "object" && typeof console.log != "undefined") {
        console.log(string);
        return;
      }
      if (typeof window == "object")
        return;
      if (typeof print == "function") {
        print(string);
        return;
      }
      throw "Unable to print message: " + String(string);
    }
  }], ["dart.collection", "dart:collection",, P, {
    "^": "",
    IterableBase_iterableToFullString: function(iterable, leftDelimiter, rightDelimiter) {
      var buffer, t1, t2;
      if (P._isToStringVisiting(iterable))
        return leftDelimiter + "..." + rightDelimiter;
      buffer = new P.StringBuffer(leftDelimiter);
      t1 = $.$get$_toStringVisiting();
      C.JSArray_methods.add$1(t1, iterable);
      try {
        t2 = buffer;
        t2._contents = P.StringBuffer__writeAll(t2.get$_contents(), iterable, ", ");
      } finally {
        if (0 >= t1.length)
          return H.ioore(t1, -1);
        t1.pop();
      }
      t1 = buffer;
      t1._contents = t1.get$_contents() + rightDelimiter;
      t1 = buffer.get$_contents();
      return t1.charCodeAt(0) == 0 ? t1 : t1;
    },
    _isToStringVisiting: function(o) {
      var i, t1;
      for (i = 0; t1 = $.$get$_toStringVisiting(), i < t1.length; ++i)
        if (o === t1[i])
          return true;
      return false;
    }
  }], ["dart.core", "dart:core",, P, {
    "^": "",
    int_parse: function(source, onError, radix) {
      var value = H.Primitives_parseInt(source, radix);
      if (value != null)
        return value;
      throw H.wrapException(new P.FormatException(source, null, null));
    },
    Error__objectToString: function(object) {
      var t1 = J.getInterceptor(object);
      if (!!t1.$isClosure)
        return t1.toString$0(object);
      return "Instance of '" + H.Primitives_objectTypeName(object) + "'";
    },
    Error_safeToString: function(object) {
      if (typeof object === "number" || typeof object === "boolean" || null == object)
        return J.toString$0$(object);
      if (typeof object === "string")
        return JSON.stringify(object);
      return P.Error__objectToString(object);
    },
    print: function(object) {
      H.printString("" + object);
    },
    bool: {
      "^": "Object;",
      toString$0: function(_) {
        return this ? "true" : "false";
      }
    },
    "+bool": 0,
    double: {
      "^": "num;"
    },
    "+double": 0,
    Error: {
      "^": "Object;"
    },
    NullThrownError: {
      "^": "Error;",
      toString$0: function(_) {
        return "Throw of null.";
      }
    },
    ArgumentError: {
      "^": "Error;_hasValue,invalidValue,name,message",
      get$_errorName: function() {
        return "Invalid argument" + (!this._hasValue ? "(s)" : "");
      },
      get$_errorExplanation: function() {
        return "";
      },
      toString$0: function(_) {
        var t1, nameString, message, prefix, explanation, errorValue;
        t1 = this.name;
        nameString = t1 != null ? " (" + t1 + ")" : "";
        t1 = this.message;
        message = t1 == null ? "" : ": " + t1;
        prefix = this.get$_errorName() + nameString + message;
        if (!this._hasValue)
          return prefix;
        explanation = this.get$_errorExplanation();
        errorValue = P.Error_safeToString(this.invalidValue);
        return prefix + explanation + ": " + H.S(errorValue);
      },
      static: {
        ArgumentError$value: function(value, $name, message) {
          return new P.ArgumentError(true, value, $name, message);
        }
      }
    },
    RangeError: {
      "^": "ArgumentError;start,end,_hasValue,invalidValue,name,message",
      get$_errorName: function() {
        return "RangeError";
      },
      get$_errorExplanation: function() {
        var t1, explanation, t2;
        t1 = this.start;
        if (t1 == null) {
          t1 = this.end;
          explanation = t1 != null ? ": Not less than or equal to " + H.S(t1) : "";
        } else {
          t2 = this.end;
          if (t2 == null)
            explanation = ": Not greater than or equal to " + H.S(t1);
          else if (t2 > t1)
            explanation = ": Not in range " + H.S(t1) + ".." + H.S(t2) + ", inclusive";
          else
            explanation = t2 < t1 ? ": Valid value range is empty" : ": Only valid value is " + H.S(t1);
        }
        return explanation;
      },
      static: {
        RangeError$value: function(value, $name, message) {
          return new P.RangeError(null, null, true, value, $name, "Value not in range");
        }
      }
    },
    IndexError: {
      "^": "ArgumentError;indexable,length>,_hasValue,invalidValue,name,message",
      get$_errorName: function() {
        return "RangeError";
      },
      get$_errorExplanation: function() {
        var t1 = this.invalidValue;
        if (typeof t1 !== "number")
          return t1.$lt();
        if (t1 < 0)
          return ": index must not be negative";
        t1 = this.length;
        if (t1 === 0)
          return ": no indices are valid";
        return ": index should be less than " + t1;
      },
      static: {
        IndexError$: function(invalidValue, indexable, $name, message, $length) {
          var t1 = $length != null ? $length : J.get$length$as(indexable);
          return new P.IndexError(indexable, t1, true, invalidValue, $name, "Index out of range");
        }
      }
    },
    UnsupportedError: {
      "^": "Error;message",
      toString$0: function(_) {
        return "Unsupported operation: " + this.message;
      },
      static: {
        UnsupportedError$: function(message) {
          return new P.UnsupportedError(message);
        }
      }
    },
    ConcurrentModificationError: {
      "^": "Error;modifiedObject",
      toString$0: function(_) {
        var t1 = this.modifiedObject;
        if (t1 == null)
          return "Concurrent modification during iteration.";
        return "Concurrent modification during iteration: " + H.S(P.Error_safeToString(t1)) + ".";
      },
      static: {
        ConcurrentModificationError$: function(modifiedObject) {
          return new P.ConcurrentModificationError(modifiedObject);
        }
      }
    },
    CyclicInitializationError: {
      "^": "Error;variableName",
      toString$0: function(_) {
        var t1 = this.variableName;
        return t1 == null ? "Reading static variable during its initialization" : "Reading static variable '" + t1 + "' during its initialization";
      }
    },
    FormatException: {
      "^": "Object;message,source,offset",
      toString$0: function(_) {
        var report = "FormatException: " + H.S(this.message);
        return report;
      }
    },
    int: {
      "^": "num;"
    },
    "+int": 0,
    List: {
      "^": "Object;$ti",
      $isIterable: 1
    },
    "+List": 0,
    Null: {
      "^": "Object;",
      toString$0: function(_) {
        return "null";
      }
    },
    "+Null": 0,
    num: {
      "^": "Object;"
    },
    "+num": 0,
    Object: {
      "^": ";",
      toString$0: function(_) {
        return "Instance of '" + H.Primitives_objectTypeName(this) + "'";
      },
      toString: function() {
        return this.toString$0(this);
      }
    },
    String: {
      "^": "Object;"
    },
    "+String": 0,
    StringBuffer: {
      "^": "Object;_contents<",
      get$length: function(_) {
        return this._contents.length;
      },
      toString$0: function(_) {
        var t1 = this._contents;
        return t1.charCodeAt(0) == 0 ? t1 : t1;
      },
      static: {
        StringBuffer__writeAll: function(string, objects, separator) {
          var iterator = new J.ArrayIterator(objects, objects.length, 0, [H.getTypeArgumentByIndex(objects, 0)]);
          if (!iterator.moveNext$0())
            return string;
          if (separator.length === 0) {
            do
              string += H.S(iterator._current);
            while (iterator.moveNext$0());
          } else {
            string += H.S(iterator._current);
            for (; iterator.moveNext$0();)
              string = string + separator + H.S(iterator._current);
          }
          return string;
        }
      }
    }
  }], ["dart.io", "dart:io",, P, {
    "^": "",
    _StdIOUtils__getStdioInputStream: function(fd) {
      throw H.wrapException(P.UnsupportedError$("StdIOUtils._getStdioInputStream"));
    }
  }], ["", "bin/atcoder_test.dart",, O, {
    "^": "",
    main: function() {
      var t1, inputs, $N, $K;
      t1 = P._StdIOUtils__getStdioInputStream($._stdinFD);
      $._stdin = t1;
      inputs = t1.readLineSync$0().split$1(0, " ");
      $N = P.int_parse(inputs.$index(0, 0), null, null);
      $K = P.int_parse(inputs.$index(0, 1), null, null);
      if (typeof $N !== "number")
        return $N.$mod();
      if (typeof $K !== "number")
        return H.iae($K);
      if (C.JSInt_methods.$mod($N, $K) === 0)
        P.print(0);
      else
        P.print(1);
      return;
    }
  }, 1]];
  setupProgram(dart, 0, 0);
  // getInterceptor methods
  J.getInterceptor = function(receiver) {
    if (typeof receiver == "number") {
      if (Math.floor(receiver) == receiver)
        return J.JSInt.prototype;
      return J.JSDouble.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 (receiver.constructor == Array)
      return J.JSArray.prototype;
    return receiver;
  };
  J.getInterceptor$as = function(receiver) {
    if (typeof receiver == "string")
      return J.JSString.prototype;
    if (receiver == null)
      return receiver;
    if (receiver.constructor == Array)
      return J.JSArray.prototype;
    return receiver;
  };
  J.get$length$as = function(receiver) {
    return J.getInterceptor$as(receiver).get$length(receiver);
  };
  J.toString$0$ = function(receiver) {
    return J.getInterceptor(receiver).toString$0(receiver);
  };
  // Output contains no constant list.
  var $ = Isolate.$isolateProperties;
  C.Interceptor_methods = J.Interceptor.prototype;
  C.JSArray_methods = J.JSArray.prototype;
  C.JSInt_methods = J.JSInt.prototype;
  C.JSString_methods = J.JSString.prototype;
  C.JS_CONST_u2C = function getTagFallback(o) {
  var s = Object.prototype.toString.call(o);
  return s.substring(8, s.length - 1);
};
  $.Closure_functionCounter = 0;
  $.BoundClosure_selfFieldNameCache = null;
  $.BoundClosure_receiverFieldNameCache = null;
  $._stdin = null;
  $._stdinFD = 0;
  $ = null;
  init.isHunkLoaded = function(hunkHash) {
    return !!$dart_deferred_initializers$[hunkHash];
  };
  init.deferredInitialized = new Object(null);
  init.isHunkInitialized = function(hunkHash) {
    return init.deferredInitialized[hunkHash];
  };
  init.initializeLoadedHunk = function(hunkHash) {
    var hunk = $dart_deferred_initializers$[hunkHash];
    if (hunk == null)
      throw "DeferredLoading state error: code with hash '" + hunkHash + "' was not loaded";
    hunk($globals$, $);
    init.deferredInitialized[hunkHash] = true;
  };
  init.deferredLibraryParts = {};
  init.deferredPartUris = [];
  init.deferredPartHashes = [];
  // Empty type-to-interceptor map.
  (function(lazies) {
    for (var i = 0; i < lazies.length;) {
      var fieldName = lazies[i++];
      var getterName = lazies[i++];
      var lazyValue = lazies[i++];
      var staticName = lazies[i++];
      Isolate.$lazy(fieldName, getterName, lazyValue, staticName);
    }
  })(["_toStringVisiting", "$get$_toStringVisiting", function() {
    return [];
  }, "_toStringVisiting"]);
  Isolate = Isolate.$finishIsolateConstructor(Isolate);
  $ = new Isolate();
  init.metadata = [];
  init.types = [];
  function convertToFastObject(properties) {
    function MyClass() {
    }
    MyClass.prototype = properties;
    new MyClass();
    return properties;
  }
  function convertToSlowObject(properties) {
    properties.__MAGIC_SLOW_PROPERTY = 1;
    delete properties.__MAGIC_SLOW_PROPERTY;
    return properties;
  }
  A = convertToFastObject(A);
  B = convertToFastObject(B);
  C = convertToFastObject(C);
  D = convertToFastObject(D);
  E = convertToFastObject(E);
  F = convertToFastObject(F);
  G = convertToFastObject(G);
  H = convertToFastObject(H);
  J = convertToFastObject(J);
  K = convertToFastObject(K);
  L = convertToFastObject(L);
  M = convertToFastObject(M);
  N = convertToFastObject(N);
  O = convertToFastObject(O);
  P = convertToFastObject(P);
  Q = convertToFastObject(Q);
  R = convertToFastObject(R);
  S = convertToFastObject(S);
  T = convertToFastObject(T);
  U = convertToFastObject(U);
  V = convertToFastObject(V);
  W = convertToFastObject(W);
  X = convertToFastObject(X);
  Y = convertToFastObject(Y);
  Z = convertToFastObject(Z);
  function init() {
    Isolate.$isolateProperties = Object.create(null);
    init.allClasses = map();
    init.getTypeFromName = function(name) {
      return init.allClasses[name];
    };
    init.interceptorsByTag = map();
    init.leafTags = map();
    init.finishedClasses = map();
    Isolate.$lazy = function(fieldName, getterName, lazyValue, staticName, prototype) {
      if (!init.lazies)
        init.lazies = Object.create(null);
      init.lazies[fieldName] = getterName;
      prototype = prototype || Isolate.$isolateProperties;
      var sentinelUndefined = {};
      var sentinelInProgress = {};
      prototype[fieldName] = sentinelUndefined;
      prototype[getterName] = function() {
        var result = this[fieldName];
        if (result == sentinelInProgress)
          H.throwCyclicInit(staticName || fieldName);
        try {
          if (result === sentinelUndefined) {
            this[fieldName] = sentinelInProgress;
            try {
              result = this[fieldName] = lazyValue();
            } finally {
              if (result === sentinelUndefined)
                this[fieldName] = null;
            }
          }
          return result;
        } finally {
          this[getterName] = function() {
            return this[fieldName];
          };
        }
      };
    };
    Isolate.$finishIsolateConstructor = function(oldIsolate) {
      var isolateProperties = oldIsolate.$isolateProperties;
      function Isolate() {
        var staticNames = Object.keys(isolateProperties);
        for (var i = 0; i < staticNames.length; i++) {
          var staticName = staticNames[i];
          this[staticName] = isolateProperties[staticName];
        }
        var lazies = init.lazies;
        var lazyInitializers = lazies ? Object.keys(lazies) : [];
        for (var i = 0; i < lazyInitializers.length; i++)
          this[lazies[lazyInitializers[i]]] = null;
        function ForceEfficientMap() {
        }
        ForceEfficientMap.prototype = this;
        new ForceEfficientMap();
        for (var i = 0; i < lazyInitializers.length; i++) {
          var lazyInitName = lazies[lazyInitializers[i]];
          this[lazyInitName] = isolateProperties[lazyInitName];
        }
      }
      Isolate.prototype = oldIsolate.prototype;
      Isolate.prototype.constructor = Isolate;
      Isolate.$isolateProperties = isolateProperties;
      Isolate.functionThatReturnsNull = oldIsolate.functionThatReturnsNull;
      return Isolate;
    };
  }
  // BEGIN invoke [main].
  (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;
    if (typeof dartMainRunner === "function")
      dartMainRunner(O.main, []);
    else
      O.main([]);
  });
  // END invoke [main].
})();

//# sourceMappingURL=hoge.js.map
