(function(global) {

'use strict';
if (global.$traceurRuntime) {
  return;
}
var $Object = Object;
var $TypeError = TypeError;
var $create = $Object.create;
var $defineProperties = $Object.defineProperties;
var $defineProperty = $Object.defineProperty;
var $freeze = $Object.freeze;
var $getOwnPropertyDescriptor = $Object.getOwnPropertyDescriptor;
var $getOwnPropertyNames = $Object.getOwnPropertyNames;
var $keys = $Object.keys;
var $hasOwnProperty = $Object.prototype.hasOwnProperty;
var $toString = $Object.prototype.toString;
var $preventExtensions = Object.preventExtensions;
var $seal = Object.seal;
var $isExtensible = Object.isExtensible;
function nonEnum(value) {
  return {
    configurable: true,
    enumerable: false,
    value: value,
    writable: true
  };
}
var method = nonEnum;
var counter = 0;
function newUniqueString() {
  return '__$' + Math.floor(Math.random() * 1e9) + '$' + ++counter + '$__';
}
var symbolInternalProperty = newUniqueString();
var symbolDescriptionProperty = newUniqueString();
var symbolDataProperty = newUniqueString();
var symbolValues = $create(null);
var privateNames = $create(null);
function isPrivateName(s) {
  return privateNames[s];
}
function createPrivateName() {
  var s = newUniqueString();
  privateNames[s] = true;
  return s;
}
function isShimSymbol(symbol) {
  return typeof symbol === 'object' && symbol instanceof SymbolValue;
}
function typeOf(v) {
  if (isShimSymbol(v))
    return 'symbol';
  return typeof v;
}
function Symbol(description) {
  var value = new SymbolValue(description);
  if (!(this instanceof Symbol))
    return value;
  throw new TypeError('Symbol cannot be new\'ed');
}
$defineProperty(Symbol.prototype, 'constructor', nonEnum(Symbol));
$defineProperty(Symbol.prototype, 'toString', method(function() {
  var symbolValue = this[symbolDataProperty];
  if (!getOption('symbols'))
    return symbolValue[symbolInternalProperty];
  if (!symbolValue)
    throw TypeError('Conversion from symbol to string');
  var desc = symbolValue[symbolDescriptionProperty];
  if (desc === undefined)
    desc = '';
  return 'Symbol(' + desc + ')';
}));
$defineProperty(Symbol.prototype, 'valueOf', method(function() {
  var symbolValue = this[symbolDataProperty];
  if (!symbolValue)
    throw TypeError('Conversion from symbol to string');
  if (!getOption('symbols'))
    return symbolValue[symbolInternalProperty];
  return symbolValue;
}));
function SymbolValue(description) {
  var key = newUniqueString();
  $defineProperty(this, symbolDataProperty, {value: this});
  $defineProperty(this, symbolInternalProperty, {value: key});
  $defineProperty(this, symbolDescriptionProperty, {value: description});
  freeze(this);
  symbolValues[key] = this;
}
$defineProperty(SymbolValue.prototype, 'constructor', nonEnum(Symbol));
$defineProperty(SymbolValue.prototype, 'toString', {
  value: Symbol.prototype.toString,
  enumerable: false
});
$defineProperty(SymbolValue.prototype, 'valueOf', {
  value: Symbol.prototype.valueOf,
  enumerable: false
});
var hashProperty = createPrivateName();
var hashPropertyDescriptor = {value: undefined};
var hashObjectProperties = {
  hash: {value: undefined},
  self: {value: undefined}
};
var hashCounter = 0;
function getOwnHashObject(object) {
  var hashObject = object[hashProperty];
  if (hashObject && hashObject.self === object)
    return hashObject;
  if ($isExtensible(object)) {
    hashObjectProperties.hash.value = hashCounter++;
    hashObjectProperties.self.value = object;
    hashPropertyDescriptor.value = $create(null, hashObjectProperties);
    $defineProperty(object, hashProperty, hashPropertyDescriptor);
    return hashPropertyDescriptor.value;
  }
  return undefined;
}
function freeze(object) {
  getOwnHashObject(object);
  return $freeze.apply(this, arguments);
}
function preventExtensions(object) {
  getOwnHashObject(object);
  return $preventExtensions.apply(this, arguments);
}
function seal(object) {
  getOwnHashObject(object);
  return $seal.apply(this, arguments);
}
freeze(SymbolValue.prototype);
function isSymbolString(s) {
  return symbolValues[s] || privateNames[s];
}
function toProperty(name) {
  if (isShimSymbol(name))
    return name[symbolInternalProperty];
  return name;
}
function removeSymbolKeys(array) {
  var rv = [];
  for (var i = 0; i < array.length; i++) {
    if (!isSymbolString(array[i])) {
      rv.push(array[i]);
    }
  }
  return rv;
}
function getOwnPropertyNames(object) {
  return removeSymbolKeys($getOwnPropertyNames(object));
}
function keys(object) {
  return removeSymbolKeys($keys(object));
}
function getOwnPropertySymbols(object) {
  var rv = [];
  var names = $getOwnPropertyNames(object);
  for (var i = 0; i < names.length; i++) {
    var symbol = symbolValues[names[i]];
    if (symbol) {
      rv.push(symbol);
    }
  }
  return rv;
}
function getOwnPropertyDescriptor(object, name) {
  return $getOwnPropertyDescriptor(object, toProperty(name));
}
function hasOwnProperty(name) {
  return $hasOwnProperty.call(this, toProperty(name));
}
function getOption(name) {
  return global.traceur && global.traceur.options[name];
}
function defineProperty(object, name, descriptor) {
  if (isShimSymbol(name)) {
    name = name[symbolInternalProperty];
  }
  $defineProperty(object, name, descriptor);
  return object;
}
function polyfillObject(Object) {
  $defineProperty(Object, 'defineProperty', {value: defineProperty});
  $defineProperty(Object, 'getOwnPropertyNames', {value: getOwnPropertyNames});
  $defineProperty(Object, 'getOwnPropertyDescriptor', {value: getOwnPropertyDescriptor});
  $defineProperty(Object.prototype, 'hasOwnProperty', {value: hasOwnProperty});
  $defineProperty(Object, 'freeze', {value: freeze});
  $defineProperty(Object, 'preventExtensions', {value: preventExtensions});
  $defineProperty(Object, 'seal', {value: seal});
  $defineProperty(Object, 'keys', {value: keys});
}
function exportStar(object) {
  for (var i = 1; i < arguments.length; i++) {
    var names = $getOwnPropertyNames(arguments[i]);
    for (var j = 0; j < names.length; j++) {
      var name = names[j];
      if (isSymbolString(name))
        continue;
      (function(mod, name) {
        $defineProperty(object, name, {
          get: function() {
            return mod[name];
          },
          enumerable: true
        });
      })(arguments[i], names[j]);
    }
  }
  return object;
}
function isObject(x) {
  return x != null && (typeof x === 'object' || typeof x === 'function');
}
function toObject(x) {
  if (x == null)
    throw $TypeError();
  return $Object(x);
}
function checkObjectCoercible(argument) {
  if (argument == null) {
    throw new TypeError('Value cannot be converted to an Object');
  }
  return argument;
}
var path = typeof require !== 'undefined' && require('path');
function relativeRequire(callerPath, requiredPath) {
  function isDirectory(path) {
    return (path.slice(-1) === '/');
  }
  function isAbsolute(path) {
    return (path.charAt(0) === '/');
  }
  function isRelative(path) {
    return (path.charAt(0) === '.');
  }
  if (isDirectory(requiredPath) || isAbsolute(requiredPath))
    return;
  return isRelative(requiredPath) ? require(path.resolve(path.dirname(callerPath), requiredPath)) : require(requiredPath);
}
function polyfillSymbol(global, Symbol) {
  if (!global.Symbol) {
    global.Symbol = Symbol;
    Object.getOwnPropertySymbols = getOwnPropertySymbols;
  }
  if (!global.Symbol.iterator) {
    global.Symbol.iterator = Symbol('Symbol.iterator');
  }
}
function setupGlobals(global) {
  polyfillSymbol(global, Symbol);
  global.Reflect = global.Reflect || {};
  global.Reflect.global = global.Reflect.global || global;
  polyfillObject(global.Object);
}
setupGlobals(global);
global.$traceurRuntime = {
  checkObjectCoercible: checkObjectCoercible,
  createPrivateName: createPrivateName,
  defineProperties: $defineProperties,
  defineProperty: $defineProperty,
  exportStar: exportStar,
  getOwnHashObject: getOwnHashObject,
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  getOwnPropertyNames: $getOwnPropertyNames,
  isObject: isObject,
  isPrivateName: isPrivateName,
  isSymbolString: isSymbolString,
  keys: $keys,
  setupGlobals: setupGlobals,
  require: relativeRequire,
  toObject: toObject,
  toProperty: toProperty,
  typeof: typeOf
};

})(typeof global !== 'undefined' ? global : this); (function() {

'use strict';
var path = typeof require !== 'undefined' && require('path');
function relativeRequire(callerPath, requiredPath) {
  function isDirectory(path) {
    return path.slice(-1) === '/';
  }
  function isAbsolute(path) {
    return path[0] === '/';
  }
  function isRelative(path) {
    return path[0] === '.';
  }
  if (isDirectory(requiredPath) || isAbsolute(requiredPath))
    return;
  return isRelative(requiredPath) ? require(path.resolve(path.dirname(callerPath), requiredPath)) : require(requiredPath);
}
$traceurRuntime.require = relativeRequire;

})(); (function() {

'use strict';
function spread() {
  var rv = [],
      j = 0,
      iterResult;
  for (var i = 0; i < arguments.length; i++) {
    var valueToSpread = $traceurRuntime.checkObjectCoercible(arguments[i]);
    if (typeof valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)] !== 'function') {
      throw new TypeError('Cannot spread non-iterable object.');
    }
    var iter = valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)]();
    while (!(iterResult = iter.next()).done) {
      rv[j++] = iterResult.value;
    }
  }
  return rv;
}
$traceurRuntime.spread = spread;

})(); (function() {

'use strict';
var $Object = Object;
var $TypeError = TypeError;
var $create = $Object.create;
var $defineProperties = $traceurRuntime.defineProperties;
var $defineProperty = $traceurRuntime.defineProperty;
var $getOwnPropertyDescriptor = $traceurRuntime.getOwnPropertyDescriptor;
var $getOwnPropertyNames = $traceurRuntime.getOwnPropertyNames;
var $getPrototypeOf = Object.getPrototypeOf;
var $__0 = Object,
    getOwnPropertyNames = $__0.getOwnPropertyNames,
    getOwnPropertySymbols = $__0.getOwnPropertySymbols;
function superDescriptor(homeObject, name) {
  var proto = $getPrototypeOf(homeObject);
  do {
    var result = $getOwnPropertyDescriptor(proto, name);
    if (result)
      return result;
    proto = $getPrototypeOf(proto);
  } while (proto);
  return undefined;
}
function superConstructor(ctor) {
  return ctor.__proto__;
}
function superCall(self, homeObject, name, args) {
  return superGet(self, homeObject, name).apply(self, args);
}
function superGet(self, homeObject, name) {
  var descriptor = superDescriptor(homeObject, name);
  if (descriptor) {
    if (!descriptor.get)
      return descriptor.value;
    return descriptor.get.call(self);
  }
  return undefined;
}
function superSet(self, homeObject, name, value) {
  var descriptor = superDescriptor(homeObject, name);
  if (descriptor && descriptor.set) {
    descriptor.set.call(self, value);
    return value;
  }
  throw $TypeError(("super has no setter '" + name + "'."));
}
function getDescriptors(object) {
  var descriptors = {};
  var names = getOwnPropertyNames(object);
  for (var i = 0; i < names.length; i++) {
    var name = names[i];
    descriptors[name] = $getOwnPropertyDescriptor(object, name);
  }
  var symbols = getOwnPropertySymbols(object);
  for (var i = 0; i < symbols.length; i++) {
    var symbol = symbols[i];
    descriptors[$traceurRuntime.toProperty(symbol)] = $getOwnPropertyDescriptor(object, $traceurRuntime.toProperty(symbol));
  }
  return descriptors;
}
function createClass(ctor, object, staticObject, superClass) {
  $defineProperty(object, 'constructor', {
    value: ctor,
    configurable: true,
    enumerable: false,
    writable: true
  });
  if (arguments.length > 3) {
    if (typeof superClass === 'function')
      ctor.__proto__ = superClass;
    ctor.prototype = $create(getProtoParent(superClass), getDescriptors(object));
  } else {
    ctor.prototype = object;
  }
  $defineProperty(ctor, 'prototype', {
    configurable: false,
    writable: false
  });
  return $defineProperties(ctor, getDescriptors(staticObject));
}
function getProtoParent(superClass) {
  if (typeof superClass === 'function') {
    var prototype = superClass.prototype;
    if ($Object(prototype) === prototype || prototype === null)
      return superClass.prototype;
    throw new $TypeError('super prototype must be an Object or null');
  }
  if (superClass === null)
    return null;
  throw new $TypeError(("Super expression must either be null or a function, not " + typeof superClass + "."));
}
function defaultSuperCall(self, homeObject, args) {
  if ($getPrototypeOf(homeObject) !== null)
    superCall(self, homeObject, 'constructor', args);
}
$traceurRuntime.createClass = createClass;
$traceurRuntime.defaultSuperCall = defaultSuperCall;
$traceurRuntime.superCall = superCall;
$traceurRuntime.superConstructor = superConstructor;
$traceurRuntime.superGet = superGet;
$traceurRuntime.superSet = superSet;

})(); (function() {

'use strict';
var createPrivateName = $traceurRuntime.createPrivateName;
var $defineProperties = $traceurRuntime.defineProperties;
var $defineProperty = $traceurRuntime.defineProperty;
var $create = Object.create;
var $TypeError = TypeError;
function nonEnum(value) {
  return {
    configurable: true,
    enumerable: false,
    value: value,
    writable: true
  };
}
var ST_NEWBORN = 0;
var ST_EXECUTING = 1;
var ST_SUSPENDED = 2;
var ST_CLOSED = 3;
var END_STATE = -2;
var RETHROW_STATE = -3;
function getInternalError(state) {
  return new Error('Traceur compiler bug: invalid state in state machine: ' + state);
}
function GeneratorContext() {
  this.state = 0;
  this.GState = ST_NEWBORN;
  this.storedException = undefined;
  this.finallyFallThrough = undefined;
  this.sent_ = undefined;
  this.returnValue = undefined;
  this.tryStack_ = [];
}
GeneratorContext.prototype = {
  pushTry: function(catchState, finallyState) {
    if (finallyState !== null) {
      var finallyFallThrough = null;
      for (var i = this.tryStack_.length - 1; i >= 0; i--) {
        if (this.tryStack_[i].catch !== undefined) {
          finallyFallThrough = this.tryStack_[i].catch;
          break;
        }
      }
      if (finallyFallThrough === null)
        finallyFallThrough = RETHROW_STATE;
      this.tryStack_.push({
        finally: finallyState,
        finallyFallThrough: finallyFallThrough
      });
    }
    if (catchState !== null) {
      this.tryStack_.push({catch: catchState});
    }
  },
  popTry: function() {
    this.tryStack_.pop();
  },
  get sent() {
    this.maybeThrow();
    return this.sent_;
  },
  set sent(v) {
    this.sent_ = v;
  },
  get sentIgnoreThrow() {
    return this.sent_;
  },
  maybeThrow: function() {
    if (this.action === 'throw') {
      this.action = 'next';
      throw this.sent_;
    }
  },
  end: function() {
    switch (this.state) {
      case END_STATE:
        return this;
      case RETHROW_STATE:
        throw this.storedException;
      default:
        throw getInternalError(this.state);
    }
  },
  handleException: function(ex) {
    this.GState = ST_CLOSED;
    this.state = END_STATE;
    throw ex;
  }
};
function nextOrThrow(ctx, moveNext, action, x) {
  switch (ctx.GState) {
    case ST_EXECUTING:
      throw new Error(("\"" + action + "\" on executing generator"));
    case ST_CLOSED:
      if (action == 'next') {
        return {
          value: undefined,
          done: true
        };
      }
      throw x;
    case ST_NEWBORN:
      if (action === 'throw') {
        ctx.GState = ST_CLOSED;
        throw x;
      }
      if (x !== undefined)
        throw $TypeError('Sent value to newborn generator');
    case ST_SUSPENDED:
      ctx.GState = ST_EXECUTING;
      ctx.action = action;
      ctx.sent = x;
      var value = moveNext(ctx);
      var done = value === ctx;
      if (done)
        value = ctx.returnValue;
      ctx.GState = done ? ST_CLOSED : ST_SUSPENDED;
      return {
        value: value,
        done: done
      };
  }
}
var ctxName = createPrivateName();
var moveNextName = createPrivateName();
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
GeneratorFunction.prototype = GeneratorFunctionPrototype;
$defineProperty(GeneratorFunctionPrototype, 'constructor', nonEnum(GeneratorFunction));
GeneratorFunctionPrototype.prototype = {
  constructor: GeneratorFunctionPrototype,
  next: function(v) {
    return nextOrThrow(this[ctxName], this[moveNextName], 'next', v);
  },
  throw: function(v) {
    return nextOrThrow(this[ctxName], this[moveNextName], 'throw', v);
  }
};
$defineProperties(GeneratorFunctionPrototype.prototype, {
  constructor: {enumerable: false},
  next: {enumerable: false},
  throw: {enumerable: false}
});
Object.defineProperty(GeneratorFunctionPrototype.prototype, Symbol.iterator, nonEnum(function() {
  return this;
}));
function createGeneratorInstance(innerFunction, functionObject, self) {
  var moveNext = getMoveNext(innerFunction, self);
  var ctx = new GeneratorContext();
  var object = $create(functionObject.prototype);
  object[ctxName] = ctx;
  object[moveNextName] = moveNext;
  return object;
}
function initGeneratorFunction(functionObject) {
  functionObject.prototype = $create(GeneratorFunctionPrototype.prototype);
  functionObject.__proto__ = GeneratorFunctionPrototype;
  return functionObject;
}
function AsyncFunctionContext() {
  GeneratorContext.call(this);
  this.err = undefined;
  var ctx = this;
  ctx.result = new Promise(function(resolve, reject) {
    ctx.resolve = resolve;
    ctx.reject = reject;
  });
}
AsyncFunctionContext.prototype = $create(GeneratorContext.prototype);
AsyncFunctionContext.prototype.end = function() {
  switch (this.state) {
    case END_STATE:
      this.resolve(this.returnValue);
      break;
    case RETHROW_STATE:
      this.reject(this.storedException);
      break;
    default:
      this.reject(getInternalError(this.state));
  }
};
AsyncFunctionContext.prototype.handleException = function() {
  this.state = RETHROW_STATE;
};
function asyncWrap(innerFunction, self) {
  var moveNext = getMoveNext(innerFunction, self);
  var ctx = new AsyncFunctionContext();
  ctx.createCallback = function(newState) {
    return function(value) {
      ctx.state = newState;
      ctx.value = value;
      moveNext(ctx);
    };
  };
  ctx.errback = function(err) {
    handleCatch(ctx, err);
    moveNext(ctx);
  };
  moveNext(ctx);
  return ctx.result;
}
function getMoveNext(innerFunction, self) {
  return function(ctx) {
    while (true) {
      try {
        return innerFunction.call(self, ctx);
      } catch (ex) {
        handleCatch(ctx, ex);
      }
    }
  };
}
function handleCatch(ctx, ex) {
  ctx.storedException = ex;
  var last = ctx.tryStack_[ctx.tryStack_.length - 1];
  if (!last) {
    ctx.handleException(ex);
    return;
  }
  ctx.state = last.catch !== undefined ? last.catch : last.finally;
  if (last.finallyFallThrough !== undefined)
    ctx.finallyFallThrough = last.finallyFallThrough;
}
$traceurRuntime.asyncWrap = asyncWrap;
$traceurRuntime.initGeneratorFunction = initGeneratorFunction;
$traceurRuntime.createGeneratorInstance = createGeneratorInstance;

})(); (function() {

function buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
  var out = [];
  if (opt_scheme) {
    out.push(opt_scheme, ':');
  }
  if (opt_domain) {
    out.push('//');
    if (opt_userInfo) {
      out.push(opt_userInfo, '@');
    }
    out.push(opt_domain);
    if (opt_port) {
      out.push(':', opt_port);
    }
  }
  if (opt_path) {
    out.push(opt_path);
  }
  if (opt_queryData) {
    out.push('?', opt_queryData);
  }
  if (opt_fragment) {
    out.push('#', opt_fragment);
  }
  return out.join('');
}
;
var splitRe = new RegExp('^' + '(?:' + '([^:/?#.]+)' + ':)?' + '(?://' + '(?:([^/?#]*)@)?' + '([\\w\\d\\-\\u0100-\\uffff.%]*)' + '(?::([0-9]+))?' + ')?' + '([^?#]+)?' + '(?:\\?([^#]*))?' + '(?:#(.*))?' + '$');
var ComponentIndex = {
  SCHEME: 1,
  USER_INFO: 2,
  DOMAIN: 3,
  PORT: 4,
  PATH: 5,
  QUERY_DATA: 6,
  FRAGMENT: 7
};
function split(uri) {
  return (uri.match(splitRe));
}
function removeDotSegments(path) {
  if (path === '/')
    return '/';
  var leadingSlash = path[0] === '/' ? '/' : '';
  var trailingSlash = path.slice(-1) === '/' ? '/' : '';
  var segments = path.split('/');
  var out = [];
  var up = 0;
  for (var pos = 0; pos < segments.length; pos++) {
    var segment = segments[pos];
    switch (segment) {
      case '':
      case '.':
        break;
      case '..':
        if (out.length)
          out.pop();
        else
          up++;
        break;
      default:
        out.push(segment);
    }
  }
  if (!leadingSlash) {
    while (up-- > 0) {
      out.unshift('..');
    }
    if (out.length === 0)
      out.push('.');
  }
  return leadingSlash + out.join('/') + trailingSlash;
}
function joinAndCanonicalizePath(parts) {
  var path = parts[ComponentIndex.PATH] || '';
  path = removeDotSegments(path);
  parts[ComponentIndex.PATH] = path;
  return buildFromEncodedParts(parts[ComponentIndex.SCHEME], parts[ComponentIndex.USER_INFO], parts[ComponentIndex.DOMAIN], parts[ComponentIndex.PORT], parts[ComponentIndex.PATH], parts[ComponentIndex.QUERY_DATA], parts[ComponentIndex.FRAGMENT]);
}
function canonicalizeUrl(url) {
  var parts = split(url);
  return joinAndCanonicalizePath(parts);
}
function resolveUrl(base, url) {
  var parts = split(url);
  var baseParts = split(base);
  if (parts[ComponentIndex.SCHEME]) {
    return joinAndCanonicalizePath(parts);
  } else {
    parts[ComponentIndex.SCHEME] = baseParts[ComponentIndex.SCHEME];
  }
  for (var i = ComponentIndex.SCHEME; i <= ComponentIndex.PORT; i++) {
    if (!parts[i]) {
      parts[i] = baseParts[i];
    }
  }
  if (parts[ComponentIndex.PATH][0] == '/') {
    return joinAndCanonicalizePath(parts);
  }
  var path = baseParts[ComponentIndex.PATH];
  var index = path.lastIndexOf('/');
  path = path.slice(0, index + 1) + parts[ComponentIndex.PATH];
  parts[ComponentIndex.PATH] = path;
  return joinAndCanonicalizePath(parts);
}
function isAbsolute(name) {
  if (!name)
    return false;
  if (name[0] === '/')
    return true;
  var parts = split(name);
  if (parts[ComponentIndex.SCHEME])
    return true;
  return false;
}
$traceurRuntime.canonicalizeUrl = canonicalizeUrl;
$traceurRuntime.isAbsolute = isAbsolute;
$traceurRuntime.removeDotSegments = removeDotSegments;
$traceurRuntime.resolveUrl = resolveUrl;

})(); (function() {

'use strict';
var types = {
  any: {name: 'any'},
  boolean: {name: 'boolean'},
  number: {name: 'number'},
  string: {name: 'string'},
  symbol: {name: 'symbol'},
  void: {name: 'void'}
};
var GenericType = function GenericType(type, argumentTypes) {
  this.type = type;
  this.argumentTypes = argumentTypes;
};
($traceurRuntime.createClass)(GenericType, {}, {});
function genericType(type) {
  for (var argumentTypes = [],
      $__1 = 1; $__1 < arguments.length; $__1++)
    argumentTypes[$__1 - 1] = arguments[$__1];
  return new GenericType(type, argumentTypes);
}
$traceurRuntime.GenericType = GenericType;
$traceurRuntime.genericType = genericType;
$traceurRuntime.type = types;

})(); (function(global) {

'use strict';
var $__2 = $traceurRuntime,
    canonicalizeUrl = $__2.canonicalizeUrl,
    resolveUrl = $__2.resolveUrl,
    isAbsolute = $__2.isAbsolute;
var moduleInstantiators = Object.create(null);
var baseURL;
if (global.location && global.location.href)
  baseURL = resolveUrl(global.location.href, './');
else
  baseURL = '';
var UncoatedModuleEntry = function UncoatedModuleEntry(url, uncoatedModule) {
  this.url = url;
  this.value_ = uncoatedModule;
};
($traceurRuntime.createClass)(UncoatedModuleEntry, {}, {});
var ModuleEvaluationError = function ModuleEvaluationError(erroneousModuleName, cause) {
  this.message = this.constructor.name + ': ' + this.stripCause(cause) + ' in ' + erroneousModuleName;
  if (!(cause instanceof $ModuleEvaluationError) && cause.stack)
    this.stack = this.stripStack(cause.stack);
  else
    this.stack = '';
};
var $ModuleEvaluationError = ModuleEvaluationError;
($traceurRuntime.createClass)(ModuleEvaluationError, {
  stripError: function(message) {
    return message.replace(/.*Error:/, this.constructor.name + ':');
  },
  stripCause: function(cause) {
    if (!cause)
      return '';
    if (!cause.message)
      return cause + '';
    return this.stripError(cause.message);
  },
  loadedBy: function(moduleName) {
    this.stack += '\n loaded by ' + moduleName;
  },
  stripStack: function(causeStack) {
    var stack = [];
    causeStack.split('\n').some((function(frame) {
      if (/UncoatedModuleInstantiator/.test(frame))
        return true;
      stack.push(frame);
    }));
    stack[0] = this.stripError(stack[0]);
    return stack.join('\n');
  }
}, {}, Error);
var UncoatedModuleInstantiator = function UncoatedModuleInstantiator(url, func) {
  $traceurRuntime.superConstructor($UncoatedModuleInstantiator).call(this, url, null);
  this.func = func;
};
var $UncoatedModuleInstantiator = UncoatedModuleInstantiator;
($traceurRuntime.createClass)(UncoatedModuleInstantiator, {getUncoatedModule: function() {
    if (this.value_)
      return this.value_;
    try {
      return this.value_ = this.func.call(global);
    } catch (ex) {
      if (ex instanceof ModuleEvaluationError) {
        ex.loadedBy(this.url);
        throw ex;
      }
      throw new ModuleEvaluationError(this.url, ex);
    }
  }}, {}, UncoatedModuleEntry);
function getUncoatedModuleInstantiator(name) {
  if (!name)
    return;
  var url = ModuleStore.normalize(name);
  return moduleInstantiators[url];
}
;
var moduleInstances = Object.create(null);
var liveModuleSentinel = {};
function Module(uncoatedModule) {
  var isLive = arguments[1];
  var coatedModule = Object.create(null);
  Object.getOwnPropertyNames(uncoatedModule).forEach((function(name) {
    var getter,
        value;
    if (isLive === liveModuleSentinel) {
      var descr = Object.getOwnPropertyDescriptor(uncoatedModule, name);
      if (descr.get)
        getter = descr.get;
    }
    if (!getter) {
      value = uncoatedModule[name];
      getter = function() {
        return value;
      };
    }
    Object.defineProperty(coatedModule, name, {
      get: getter,
      enumerable: true
    });
  }));
  Object.preventExtensions(coatedModule);
  return coatedModule;
}
var ModuleStore = {
  normalize: function(name, refererName, refererAddress) {
    if (typeof name !== "string")
      throw new TypeError("module name must be a string, not " + typeof name);
    if (isAbsolute(name))
      return canonicalizeUrl(name);
    if (/[^\.]\/\.\.\//.test(name)) {
      throw new Error('module name embeds /../: ' + name);
    }
    if (name[0] === '.' && refererName)
      return resolveUrl(refererName, name);
    return canonicalizeUrl(name);
  },
  get: function(normalizedName) {
    var m = getUncoatedModuleInstantiator(normalizedName);
    if (!m)
      return undefined;
    var moduleInstance = moduleInstances[m.url];
    if (moduleInstance)
      return moduleInstance;
    moduleInstance = Module(m.getUncoatedModule(), liveModuleSentinel);
    return moduleInstances[m.url] = moduleInstance;
  },
  set: function(normalizedName, module) {
    normalizedName = String(normalizedName);
    moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, (function() {
      return module;
    }));
    moduleInstances[normalizedName] = module;
  },
  get baseURL() {
    return baseURL;
  },
  set baseURL(v) {
    baseURL = String(v);
  },
  registerModule: function(name, func) {
    var normalizedName = ModuleStore.normalize(name);
    if (moduleInstantiators[normalizedName])
      throw new Error('duplicate module named ' + normalizedName);
    moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, func);
  },
  bundleStore: Object.create(null),
  register: function(name, deps, func) {
    if (!deps || !deps.length && !func.length) {
      this.registerModule(name, func);
    } else {
      this.bundleStore[name] = {
        deps: deps,
        execute: function() {
          var $__0 = arguments;
          var depMap = {};
          deps.forEach((function(dep, index) {
            return depMap[dep] = $__0[index];
          }));
          var registryEntry = func.call(this, depMap);
          registryEntry.execute.call(this);
          return registryEntry.exports;
        }
      };
    }
  },
  getAnonymousModule: function(func) {
    return new Module(func.call(global), liveModuleSentinel);
  },
  getForTesting: function(name) {
    var $__0 = this;
    if (!this.testingPrefix_) {
      Object.keys(moduleInstances).some((function(key) {
        var m = /(traceur@[^\/]*\/)/.exec(key);
        if (m) {
          $__0.testingPrefix_ = m[1];
          return true;
        }
      }));
    }
    return this.get(this.testingPrefix_ + name);
  }
};
ModuleStore.set('@traceur/src/runtime/ModuleStore', new Module({ModuleStore: ModuleStore}));
var setupGlobals = $traceurRuntime.setupGlobals;
$traceurRuntime.setupGlobals = function(global) {
  setupGlobals(global);
};
$traceurRuntime.ModuleStore = ModuleStore;
global.System = {
  register: ModuleStore.register.bind(ModuleStore),
  get: ModuleStore.get,
  set: ModuleStore.set,
  normalize: ModuleStore.normalize
};
$traceurRuntime.getModuleImpl = function(name) {
  var instantiator = getUncoatedModuleInstantiator(name);
  return instantiator && instantiator.getUncoatedModule();
};

})(typeof global !== 'undefined' ? global : this); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/utils”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/utils";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/utils", path);
}
var $ceil = Math.ceil;
var $floor = Math.floor;
var $isFinite = isFinite;
var $isNaN = isNaN;
var $pow = Math.pow;
var $min = Math.min;
var toObject = $traceurRuntime.toObject;
function toUint32(x) {
  return x >>> 0;
}
function isObject(x) {
  return x && (typeof x === 'object' || typeof x === 'function');
}
function isCallable(x) {
  return typeof x === 'function';
}
function isNumber(x) {
  return typeof x === 'number';
}
function toInteger(x) {
  x = +x;
  if ($isNaN(x))
    return 0;
  if (x === 0 || !$isFinite(x))
    return x;
  return x > 0 ? $floor(x) : $ceil(x);
}
var MAX_SAFE_LENGTH = $pow(2, 53) - 1;
function toLength(x) {
  var len = toInteger(x);
  return len < 0 ? 0 : $min(len, MAX_SAFE_LENGTH);
}
function checkIterable(x) {
  return !isObject(x) ? undefined : x[Symbol.iterator];
}
function isConstructor(x) {
  return isCallable(x);
}
function createIteratorResultObject(value, done) {
  return {
    value: value,
    done: done
  };
}
function maybeDefine(object, name, descr) {
  if (!(name in object)) {
    Object.defineProperty(object, name, descr);
  }
}
function maybeDefineMethod(object, name, value) {
  maybeDefine(object, name, {
    value: value,
    configurable: true,
    enumerable: false,
    writable: true
  });
}
function maybeDefineConst(object, name, value) {
  maybeDefine(object, name, {
    value: value,
    configurable: false,
    enumerable: false,
    writable: false
  });
}
function maybeAddFunctions(object, functions) {
  for (var i = 0; i < functions.length; i += 2) {
    var name = functions[i];
    var value = functions[i + 1];
    maybeDefineMethod(object, name, value);
  }
}
function maybeAddConsts(object, consts) {
  for (var i = 0; i < consts.length; i += 2) {
    var name = consts[i];
    var value = consts[i + 1];
    maybeDefineConst(object, name, value);
  }
}
function maybeAddIterator(object, func, Symbol) {
  if (!Symbol || !Symbol.iterator || object[Symbol.iterator])
    return;
  if (object['@@iterator'])
    func = object['@@iterator'];
  Object.defineProperty(object, Symbol.iterator, {
    value: func,
    configurable: true,
    enumerable: false,
    writable: true
  });
}
var polyfills = [];
function registerPolyfill(func) {
  polyfills.push(func);
}
function polyfillAll(global) {
  polyfills.forEach((function(f) {
    return f(global);
  }));
}
return {
  get toObject() {
    return toObject;
  },
  get toUint32() {
    return toUint32;
  },
  get isObject() {
    return isObject;
  },
  get isCallable() {
    return isCallable;
  },
  get isNumber() {
    return isNumber;
  },
  get toInteger() {
    return toInteger;
  },
  get toLength() {
    return toLength;
  },
  get checkIterable() {
    return checkIterable;
  },
  get isConstructor() {
    return isConstructor;
  },
  get createIteratorResultObject() {
    return createIteratorResultObject;
  },
  get maybeDefine() {
    return maybeDefine;
  },
  get maybeDefineMethod() {
    return maybeDefineMethod;
  },
  get maybeDefineConst() {
    return maybeDefineConst;
  },
  get maybeAddFunctions() {
    return maybeAddFunctions;
  },
  get maybeAddConsts() {
    return maybeAddConsts;
  },
  get maybeAddIterator() {
    return maybeAddIterator;
  },
  get registerPolyfill() {
    return registerPolyfill;
  },
  get polyfillAll() {
    return polyfillAll;
  }
};

}); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Map”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Map";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Map", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    isObject = $__0.isObject,
    maybeAddIterator = $__0.maybeAddIterator,
    registerPolyfill = $__0.registerPolyfill;
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
var $hasOwnProperty = Object.prototype.hasOwnProperty;
var deletedSentinel = {};
function lookupIndex(map, key) {
  if (isObject(key)) {
    var hashObject = getOwnHashObject(key);
    return hashObject && map.objectIndex_[hashObject.hash];
  }
  if (typeof key === 'string')
    return map.stringIndex_[key];
  return map.primitiveIndex_[key];
}
function initMap(map) {
  map.entries_ = [];
  map.objectIndex_ = Object.create(null);
  map.stringIndex_ = Object.create(null);
  map.primitiveIndex_ = Object.create(null);
  map.deletedCount_ = 0;
}
var Map = function Map() {
  var iterable = arguments[0];
  if (!isObject(this))
    throw new TypeError('Map called on incompatible type');
  if ($hasOwnProperty.call(this, 'entries_')) {
    throw new TypeError('Map can not be reentrantly initialised');
  }
  initMap(this);
  if (iterable !== null && iterable !== undefined) {
    for (var $__2 = iterable[$traceurRuntime.toProperty(Symbol.iterator)](),
        $__3; !($__3 = $__2.next()).done; ) {
      var $__4 = $__3.value,
          key = $__4[0],
          value = $__4[1];
      {
        this.set(key, value);
      }
    }
  }
};
($traceurRuntime.createClass)(Map, {
  get size() {
    return this.entries_.length / 2 - this.deletedCount_;
  },
  get: function(key) {
    var index = lookupIndex(this, key);
    if (index !== undefined)
      return this.entries_[index + 1];
  },
  set: function(key, value) {
    var objectMode = isObject(key);
    var stringMode = typeof key === 'string';
    var index = lookupIndex(this, key);
    if (index !== undefined) {
      this.entries_[index + 1] = value;
    } else {
      index = this.entries_.length;
      this.entries_[index] = key;
      this.entries_[index + 1] = value;
      if (objectMode) {
        var hashObject = getOwnHashObject(key);
        var hash = hashObject.hash;
        this.objectIndex_[hash] = index;
      } else if (stringMode) {
        this.stringIndex_[key] = index;
      } else {
        this.primitiveIndex_[key] = index;
      }
    }
    return this;
  },
  has: function(key) {
    return lookupIndex(this, key) !== undefined;
  },
  delete: function(key) {
    var objectMode = isObject(key);
    var stringMode = typeof key === 'string';
    var index;
    var hash;
    if (objectMode) {
      var hashObject = getOwnHashObject(key);
      if (hashObject) {
        index = this.objectIndex_[hash = hashObject.hash];
        delete this.objectIndex_[hash];
      }
    } else if (stringMode) {
      index = this.stringIndex_[key];
      delete this.stringIndex_[key];
    } else {
      index = this.primitiveIndex_[key];
      delete this.primitiveIndex_[key];
    }
    if (index !== undefined) {
      this.entries_[index] = deletedSentinel;
      this.entries_[index + 1] = undefined;
      this.deletedCount_++;
      return true;
    }
    return false;
  },
  clear: function() {
    initMap(this);
  },
  forEach: function(callbackFn) {
    var thisArg = arguments[1];
    for (var i = 0; i < this.entries_.length; i += 2) {
      var key = this.entries_[i];
      var value = this.entries_[i + 1];
      if (key === deletedSentinel)
        continue;
      callbackFn.call(thisArg, value, key, this);
    }
  },
  entries: $traceurRuntime.initGeneratorFunction(function $__5() {
    var i,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < this.entries_.length) ? 8 : -2;
            break;
          case 4:
            i += 2;
            $ctx.state = 12;
            break;
          case 8:
            key = this.entries_[i];
            value = this.entries_[i + 1];
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = (key === deletedSentinel) ? 4 : 6;
            break;
          case 6:
            $ctx.state = 2;
            return [key, value];
          case 2:
            $ctx.maybeThrow();
            $ctx.state = 4;
            break;
          default:
            return $ctx.end();
        }
    }, $__5, this);
  }),
  keys: $traceurRuntime.initGeneratorFunction(function $__6() {
    var i,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < this.entries_.length) ? 8 : -2;
            break;
          case 4:
            i += 2;
            $ctx.state = 12;
            break;
          case 8:
            key = this.entries_[i];
            value = this.entries_[i + 1];
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = (key === deletedSentinel) ? 4 : 6;
            break;
          case 6:
            $ctx.state = 2;
            return key;
          case 2:
            $ctx.maybeThrow();
            $ctx.state = 4;
            break;
          default:
            return $ctx.end();
        }
    }, $__6, this);
  }),
  values: $traceurRuntime.initGeneratorFunction(function $__7() {
    var i,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < this.entries_.length) ? 8 : -2;
            break;
          case 4:
            i += 2;
            $ctx.state = 12;
            break;
          case 8:
            key = this.entries_[i];
            value = this.entries_[i + 1];
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = (key === deletedSentinel) ? 4 : 6;
            break;
          case 6:
            $ctx.state = 2;
            return value;
          case 2:
            $ctx.maybeThrow();
            $ctx.state = 4;
            break;
          default:
            return $ctx.end();
        }
    }, $__7, this);
  })
}, {});
Object.defineProperty(Map.prototype, Symbol.iterator, {
  configurable: true,
  writable: true,
  value: Map.prototype.entries
});
function polyfillMap(global) {
  var $__4 = global,
      Object = $__4.Object,
      Symbol = $__4.Symbol;
  if (!global.Map)
    global.Map = Map;
  var mapPrototype = global.Map.prototype;
  if (mapPrototype.entries === undefined)
    global.Map = Map;
  if (mapPrototype.entries) {
    maybeAddIterator(mapPrototype, mapPrototype.entries, Symbol);
    maybeAddIterator(Object.getPrototypeOf(new global.Map().entries()), function() {
      return this;
    }, Symbol);
  }
}
registerPolyfill(polyfillMap);
return {
  get Map() {
    return Map;
  },
  get polyfillMap() {
    return polyfillMap;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Map” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Set”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Set";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Set", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    isObject = $__0.isObject,
    maybeAddIterator = $__0.maybeAddIterator,
    registerPolyfill = $__0.registerPolyfill;
var Map = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/Map").Map;
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
var $hasOwnProperty = Object.prototype.hasOwnProperty;
function initSet(set) {
  set.map_ = new Map();
}
var Set = function Set() {
  var iterable = arguments[0];
  if (!isObject(this))
    throw new TypeError('Set called on incompatible type');
  if ($hasOwnProperty.call(this, 'map_')) {
    throw new TypeError('Set can not be reentrantly initialised');
  }
  initSet(this);
  if (iterable !== null && iterable !== undefined) {
    for (var $__4 = iterable[$traceurRuntime.toProperty(Symbol.iterator)](),
        $__5; !($__5 = $__4.next()).done; ) {
      var item = $__5.value;
      {
        this.add(item);
      }
    }
  }
};
($traceurRuntime.createClass)(Set, {
  get size() {
    return this.map_.size;
  },
  has: function(key) {
    return this.map_.has(key);
  },
  add: function(key) {
    this.map_.set(key, key);
    return this;
  },
  delete: function(key) {
    return this.map_.delete(key);
  },
  clear: function() {
    return this.map_.clear();
  },
  forEach: function(callbackFn) {
    var thisArg = arguments[1];
    var $__2 = this;
    return this.map_.forEach((function(value, key) {
      callbackFn.call(thisArg, key, key, $__2);
    }));
  },
  values: $traceurRuntime.initGeneratorFunction(function $__7() {
    var $__8,
        $__9;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            $__8 = this.map_.keys()[Symbol.iterator]();
            $ctx.sent = void 0;
            $ctx.action = 'next';
            $ctx.state = 12;
            break;
          case 12:
            $__9 = $__8[$ctx.action]($ctx.sentIgnoreThrow);
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = ($__9.done) ? 3 : 2;
            break;
          case 3:
            $ctx.sent = $__9.value;
            $ctx.state = -2;
            break;
          case 2:
            $ctx.state = 12;
            return $__9.value;
          default:
            return $ctx.end();
        }
    }, $__7, this);
  }),
  entries: $traceurRuntime.initGeneratorFunction(function $__10() {
    var $__11,
        $__12;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            $__11 = this.map_.entries()[Symbol.iterator]();
            $ctx.sent = void 0;
            $ctx.action = 'next';
            $ctx.state = 12;
            break;
          case 12:
            $__12 = $__11[$ctx.action]($ctx.sentIgnoreThrow);
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = ($__12.done) ? 3 : 2;
            break;
          case 3:
            $ctx.sent = $__12.value;
            $ctx.state = -2;
            break;
          case 2:
            $ctx.state = 12;
            return $__12.value;
          default:
            return $ctx.end();
        }
    }, $__10, this);
  })
}, {});
Object.defineProperty(Set.prototype, Symbol.iterator, {
  configurable: true,
  writable: true,
  value: Set.prototype.values
});
Object.defineProperty(Set.prototype, 'keys', {
  configurable: true,
  writable: true,
  value: Set.prototype.values
});
function polyfillSet(global) {
  var $__6 = global,
      Object = $__6.Object,
      Symbol = $__6.Symbol;
  if (!global.Set)
    global.Set = Set;
  var setPrototype = global.Set.prototype;
  if (setPrototype.values) {
    maybeAddIterator(setPrototype, setPrototype.values, Symbol);
    maybeAddIterator(Object.getPrototypeOf(new global.Set().values()), function() {
      return this;
    }, Symbol);
  }
}
registerPolyfill(polyfillSet);
return {
  get Set() {
    return Set;
  },
  get polyfillSet() {
    return polyfillSet;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Set” + ''); System.register(“traceur-runtime@0.0.74/node_modules/rsvp/lib/rsvp/asap”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/node_modules/rsvp/lib/rsvp/asap";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/node_modules/rsvp/lib/rsvp/asap", path);
}
var len = 0;
function asap(callback, arg) {
  queue[len] = callback;
  queue[len + 1] = arg;
  len += 2;
  if (len === 2) {
    scheduleFlush();
  }
}
var $__default = asap;
var browserGlobal = (typeof window !== 'undefined') ? window : {};
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
function useNextTick() {
  return function() {
    process.nextTick(flush);
  };
}
function useMutationObserver() {
  var iterations = 0;
  var observer = new BrowserMutationObserver(flush);
  var node = document.createTextNode('');
  observer.observe(node, {characterData: true});
  return function() {
    node.data = (iterations = ++iterations % 2);
  };
}
function useMessageChannel() {
  var channel = new MessageChannel();
  channel.port1.onmessage = flush;
  return function() {
    channel.port2.postMessage(0);
  };
}
function useSetTimeout() {
  return function() {
    setTimeout(flush, 1);
  };
}
var queue = new Array(1000);
function flush() {
  for (var i = 0; i < len; i += 2) {
    var callback = queue[i];
    var arg = queue[i + 1];
    callback(arg);
    queue[i] = undefined;
    queue[i + 1] = undefined;
  }
  len = 0;
}
var scheduleFlush;
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
  scheduleFlush = useNextTick();
} else if (BrowserMutationObserver) {
  scheduleFlush = useMutationObserver();
} else if (isWorker) {
  scheduleFlush = useMessageChannel();
} else {
  scheduleFlush = useSetTimeout();
}
return {get default() {
    return $__default;
  }};

}); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Promise”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Promise";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Promise", path);
}
var async = System.get("traceur-runtime@0.0.74/node_modules/rsvp/lib/rsvp/asap").default;
var registerPolyfill = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils").registerPolyfill;
var promiseRaw = {};
function isPromise(x) {
  return x && typeof x === 'object' && x.status_ !== undefined;
}
function idResolveHandler(x) {
  return x;
}
function idRejectHandler(x) {
  throw x;
}
function chain(promise) {
  var onResolve = arguments[1] !== (void 0) ? arguments[1] : idResolveHandler;
  var onReject = arguments[2] !== (void 0) ? arguments[2] : idRejectHandler;
  var deferred = getDeferred(promise.constructor);
  switch (promise.status_) {
    case undefined:
      throw TypeError;
    case 0:
      promise.onResolve_.push(onResolve, deferred);
      promise.onReject_.push(onReject, deferred);
      break;
    case +1:
      promiseEnqueue(promise.value_, [onResolve, deferred]);
      break;
    case -1:
      promiseEnqueue(promise.value_, [onReject, deferred]);
      break;
  }
  return deferred.promise;
}
function getDeferred(C) {
  if (this === $Promise) {
    var promise = promiseInit(new $Promise(promiseRaw));
    return {
      promise: promise,
      resolve: (function(x) {
        promiseResolve(promise, x);
      }),
      reject: (function(r) {
        promiseReject(promise, r);
      })
    };
  } else {
    var result = {};
    result.promise = new C((function(resolve, reject) {
      result.resolve = resolve;
      result.reject = reject;
    }));
    return result;
  }
}
function promiseSet(promise, status, value, onResolve, onReject) {
  promise.status_ = status;
  promise.value_ = value;
  promise.onResolve_ = onResolve;
  promise.onReject_ = onReject;
  return promise;
}
function promiseInit(promise) {
  return promiseSet(promise, 0, undefined, [], []);
}
var Promise = function Promise(resolver) {
  if (resolver === promiseRaw)
    return;
  if (typeof resolver !== 'function')
    throw new TypeError;
  var promise = promiseInit(this);
  try {
    resolver((function(x) {
      promiseResolve(promise, x);
    }), (function(r) {
      promiseReject(promise, r);
    }));
  } catch (e) {
    promiseReject(promise, e);
  }
};
($traceurRuntime.createClass)(Promise, {
  catch: function(onReject) {
    return this.then(undefined, onReject);
  },
  then: function(onResolve, onReject) {
    if (typeof onResolve !== 'function')
      onResolve = idResolveHandler;
    if (typeof onReject !== 'function')
      onReject = idRejectHandler;
    var that = this;
    var constructor = this.constructor;
    return chain(this, function(x) {
      x = promiseCoerce(constructor, x);
      return x === that ? onReject(new TypeError) : isPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
    }, onReject);
  }
}, {
  resolve: function(x) {
    if (this === $Promise) {
      if (isPromise(x)) {
        return x;
      }
      return promiseSet(new $Promise(promiseRaw), +1, x);
    } else {
      return new this(function(resolve, reject) {
        resolve(x);
      });
    }
  },
  reject: function(r) {
    if (this === $Promise) {
      return promiseSet(new $Promise(promiseRaw), -1, r);
    } else {
      return new this((function(resolve, reject) {
        reject(r);
      }));
    }
  },
  all: function(values) {
    var deferred = getDeferred(this);
    var resolutions = [];
    try {
      var count = values.length;
      if (count === 0) {
        deferred.resolve(resolutions);
      } else {
        for (var i = 0; i < values.length; i++) {
          this.resolve(values[i]).then(function(i, x) {
            resolutions[i] = x;
            if (--count === 0)
              deferred.resolve(resolutions);
          }.bind(undefined, i), (function(r) {
            deferred.reject(r);
          }));
        }
      }
    } catch (e) {
      deferred.reject(e);
    }
    return deferred.promise;
  },
  race: function(values) {
    var deferred = getDeferred(this);
    try {
      for (var i = 0; i < values.length; i++) {
        this.resolve(values[i]).then((function(x) {
          deferred.resolve(x);
        }), (function(r) {
          deferred.reject(r);
        }));
      }
    } catch (e) {
      deferred.reject(e);
    }
    return deferred.promise;
  }
});
var $Promise = Promise;
var $PromiseReject = $Promise.reject;
function promiseResolve(promise, x) {
  promiseDone(promise, +1, x, promise.onResolve_);
}
function promiseReject(promise, r) {
  promiseDone(promise, -1, r, promise.onReject_);
}
function promiseDone(promise, status, value, reactions) {
  if (promise.status_ !== 0)
    return;
  promiseEnqueue(value, reactions);
  promiseSet(promise, status, value);
}
function promiseEnqueue(value, tasks) {
  async((function() {
    for (var i = 0; i < tasks.length; i += 2) {
      promiseHandle(value, tasks[i], tasks[i + 1]);
    }
  }));
}
function promiseHandle(value, handler, deferred) {
  try {
    var result = handler(value);
    if (result === deferred.promise)
      throw new TypeError;
    else if (isPromise(result))
      chain(result, deferred.resolve, deferred.reject);
    else
      deferred.resolve(result);
  } catch (e) {
    try {
      deferred.reject(e);
    } catch (e) {}
  }
}
var thenableSymbol = '@@thenable';
function isObject(x) {
  return x && (typeof x === 'object' || typeof x === 'function');
}
function promiseCoerce(constructor, x) {
  if (!isPromise(x) && isObject(x)) {
    var then;
    try {
      then = x.then;
    } catch (r) {
      var promise = $PromiseReject.call(constructor, r);
      x[thenableSymbol] = promise;
      return promise;
    }
    if (typeof then === 'function') {
      var p = x[thenableSymbol];
      if (p) {
        return p;
      } else {
        var deferred = getDeferred(constructor);
        x[thenableSymbol] = deferred.promise;
        try {
          then.call(x, deferred.resolve, deferred.reject);
        } catch (r) {
          deferred.reject(r);
        }
        return deferred.promise;
      }
    }
  }
  return x;
}
function polyfillPromise(global) {
  if (!global.Promise)
    global.Promise = Promise;
}
registerPolyfill(polyfillPromise);
return {
  get Promise() {
    return Promise;
  },
  get polyfillPromise() {
    return polyfillPromise;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Promise” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/StringIterator”, [], function() {

"use strict";
var $__2;
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/StringIterator";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/StringIterator", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    createIteratorResultObject = $__0.createIteratorResultObject,
    isObject = $__0.isObject;
var toProperty = $traceurRuntime.toProperty;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var iteratedString = Symbol('iteratedString');
var stringIteratorNextIndex = Symbol('stringIteratorNextIndex');
var StringIterator = function StringIterator() {};
($traceurRuntime.createClass)(StringIterator, ($__2 = {}, Object.defineProperty($__2, "next", {
  value: function() {
    var o = this;
    if (!isObject(o) || !hasOwnProperty.call(o, iteratedString)) {
      throw new TypeError('this must be a StringIterator object');
    }
    var s = o[toProperty(iteratedString)];
    if (s === undefined) {
      return createIteratorResultObject(undefined, true);
    }
    var position = o[toProperty(stringIteratorNextIndex)];
    var len = s.length;
    if (position >= len) {
      o[toProperty(iteratedString)] = undefined;
      return createIteratorResultObject(undefined, true);
    }
    var first = s.charCodeAt(position);
    var resultString;
    if (first < 0xD800 || first > 0xDBFF || position + 1 === len) {
      resultString = String.fromCharCode(first);
    } else {
      var second = s.charCodeAt(position + 1);
      if (second < 0xDC00 || second > 0xDFFF) {
        resultString = String.fromCharCode(first);
      } else {
        resultString = String.fromCharCode(first) + String.fromCharCode(second);
      }
    }
    o[toProperty(stringIteratorNextIndex)] = position + resultString.length;
    return createIteratorResultObject(resultString, false);
  },
  configurable: true,
  enumerable: true,
  writable: true
}), Object.defineProperty($__2, Symbol.iterator, {
  value: function() {
    return this;
  },
  configurable: true,
  enumerable: true,
  writable: true
}), $__2), {});
function createStringIterator(string) {
  var s = String(string);
  var iterator = Object.create(StringIterator.prototype);
  iterator[toProperty(iteratedString)] = s;
  iterator[toProperty(stringIteratorNextIndex)] = 0;
  return iterator;
}
return {get createStringIterator() {
    return createStringIterator;
  }};

}); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/String”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/String";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/String", path);
}
var createStringIterator = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/StringIterator").createStringIterator;
var $__1 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    maybeAddFunctions = $__1.maybeAddFunctions,
    maybeAddIterator = $__1.maybeAddIterator,
    registerPolyfill = $__1.registerPolyfill;
var $toString = Object.prototype.toString;
var $indexOf = String.prototype.indexOf;
var $lastIndexOf = String.prototype.lastIndexOf;
function startsWith(search) {
  var string = String(this);
  if (this == null || $toString.call(search) == '[object RegExp]') {
    throw TypeError();
  }
  var stringLength = string.length;
  var searchString = String(search);
  var searchLength = searchString.length;
  var position = arguments.length > 1 ? arguments[1] : undefined;
  var pos = position ? Number(position) : 0;
  if (isNaN(pos)) {
    pos = 0;
  }
  var start = Math.min(Math.max(pos, 0), stringLength);
  return $indexOf.call(string, searchString, pos) == start;
}
function endsWith(search) {
  var string = String(this);
  if (this == null || $toString.call(search) == '[object RegExp]') {
    throw TypeError();
  }
  var stringLength = string.length;
  var searchString = String(search);
  var searchLength = searchString.length;
  var pos = stringLength;
  if (arguments.length > 1) {
    var position = arguments[1];
    if (position !== undefined) {
      pos = position ? Number(position) : 0;
      if (isNaN(pos)) {
        pos = 0;
      }
    }
  }
  var end = Math.min(Math.max(pos, 0), stringLength);
  var start = end - searchLength;
  if (start < 0) {
    return false;
  }
  return $lastIndexOf.call(string, searchString, start) == start;
}
function contains(search) {
  if (this == null) {
    throw TypeError();
  }
  var string = String(this);
  var stringLength = string.length;
  var searchString = String(search);
  var searchLength = searchString.length;
  var position = arguments.length > 1 ? arguments[1] : undefined;
  var pos = position ? Number(position) : 0;
  if (isNaN(pos)) {
    pos = 0;
  }
  var start = Math.min(Math.max(pos, 0), stringLength);
  return $indexOf.call(string, searchString, pos) != -1;
}
function repeat(count) {
  if (this == null) {
    throw TypeError();
  }
  var string = String(this);
  var n = count ? Number(count) : 0;
  if (isNaN(n)) {
    n = 0;
  }
  if (n < 0 || n == Infinity) {
    throw RangeError();
  }
  if (n == 0) {
    return '';
  }
  var result = '';
  while (n--) {
    result += string;
  }
  return result;
}
function codePointAt(position) {
  if (this == null) {
    throw TypeError();
  }
  var string = String(this);
  var size = string.length;
  var index = position ? Number(position) : 0;
  if (isNaN(index)) {
    index = 0;
  }
  if (index < 0 || index >= size) {
    return undefined;
  }
  var first = string.charCodeAt(index);
  var second;
  if (first >= 0xD800 && first <= 0xDBFF && size > index + 1) {
    second = string.charCodeAt(index + 1);
    if (second >= 0xDC00 && second <= 0xDFFF) {
      return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
    }
  }
  return first;
}
function raw(callsite) {
  var raw = callsite.raw;
  var len = raw.length >>> 0;
  if (len === 0)
    return '';
  var s = '';
  var i = 0;
  while (true) {
    s += raw[i];
    if (i + 1 === len)
      return s;
    s += arguments[++i];
  }
}
function fromCodePoint() {
  var codeUnits = [];
  var floor = Math.floor;
  var highSurrogate;
  var lowSurrogate;
  var index = -1;
  var length = arguments.length;
  if (!length) {
    return '';
  }
  while (++index < length) {
    var codePoint = Number(arguments[index]);
    if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || floor(codePoint) != codePoint) {
      throw RangeError('Invalid code point: ' + codePoint);
    }
    if (codePoint <= 0xFFFF) {
      codeUnits.push(codePoint);
    } else {
      codePoint -= 0x10000;
      highSurrogate = (codePoint >> 10) + 0xD800;
      lowSurrogate = (codePoint % 0x400) + 0xDC00;
      codeUnits.push(highSurrogate, lowSurrogate);
    }
  }
  return String.fromCharCode.apply(null, codeUnits);
}
function stringPrototypeIterator() {
  var o = $traceurRuntime.checkObjectCoercible(this);
  var s = String(o);
  return createStringIterator(s);
}
function polyfillString(global) {
  var String = global.String;
  maybeAddFunctions(String.prototype, ['codePointAt', codePointAt, 'contains', contains, 'endsWith', endsWith, 'startsWith', startsWith, 'repeat', repeat]);
  maybeAddFunctions(String, ['fromCodePoint', fromCodePoint, 'raw', raw]);
  maybeAddIterator(String.prototype, stringPrototypeIterator, Symbol);
}
registerPolyfill(polyfillString);
return {
  get startsWith() {
    return startsWith;
  },
  get endsWith() {
    return endsWith;
  },
  get contains() {
    return contains;
  },
  get repeat() {
    return repeat;
  },
  get codePointAt() {
    return codePointAt;
  },
  get raw() {
    return raw;
  },
  get fromCodePoint() {
    return fromCodePoint;
  },
  get stringPrototypeIterator() {
    return stringPrototypeIterator;
  },
  get polyfillString() {
    return polyfillString;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/String” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/ArrayIterator”, [], function() {

"use strict";
var $__2;
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/ArrayIterator";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/ArrayIterator", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    toObject = $__0.toObject,
    toUint32 = $__0.toUint32,
    createIteratorResultObject = $__0.createIteratorResultObject;
var ARRAY_ITERATOR_KIND_KEYS = 1;
var ARRAY_ITERATOR_KIND_VALUES = 2;
var ARRAY_ITERATOR_KIND_ENTRIES = 3;
var ArrayIterator = function ArrayIterator() {};
($traceurRuntime.createClass)(ArrayIterator, ($__2 = {}, Object.defineProperty($__2, "next", {
  value: function() {
    var iterator = toObject(this);
    var array = iterator.iteratorObject_;
    if (!array) {
      throw new TypeError('Object is not an ArrayIterator');
    }
    var index = iterator.arrayIteratorNextIndex_;
    var itemKind = iterator.arrayIterationKind_;
    var length = toUint32(array.length);
    if (index >= length) {
      iterator.arrayIteratorNextIndex_ = Infinity;
      return createIteratorResultObject(undefined, true);
    }
    iterator.arrayIteratorNextIndex_ = index + 1;
    if (itemKind == ARRAY_ITERATOR_KIND_VALUES)
      return createIteratorResultObject(array[index], false);
    if (itemKind == ARRAY_ITERATOR_KIND_ENTRIES)
      return createIteratorResultObject([index, array[index]], false);
    return createIteratorResultObject(index, false);
  },
  configurable: true,
  enumerable: true,
  writable: true
}), Object.defineProperty($__2, Symbol.iterator, {
  value: function() {
    return this;
  },
  configurable: true,
  enumerable: true,
  writable: true
}), $__2), {});
function createArrayIterator(array, kind) {
  var object = toObject(array);
  var iterator = new ArrayIterator;
  iterator.iteratorObject_ = object;
  iterator.arrayIteratorNextIndex_ = 0;
  iterator.arrayIterationKind_ = kind;
  return iterator;
}
function entries() {
  return createArrayIterator(this, ARRAY_ITERATOR_KIND_ENTRIES);
}
function keys() {
  return createArrayIterator(this, ARRAY_ITERATOR_KIND_KEYS);
}
function values() {
  return createArrayIterator(this, ARRAY_ITERATOR_KIND_VALUES);
}
return {
  get entries() {
    return entries;
  },
  get keys() {
    return keys;
  },
  get values() {
    return values;
  }
};

}); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Array”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Array";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Array", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/ArrayIterator"),
    entries = $__0.entries,
    keys = $__0.keys,
    values = $__0.values;
var $__1 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    checkIterable = $__1.checkIterable,
    isCallable = $__1.isCallable,
    isConstructor = $__1.isConstructor,
    maybeAddFunctions = $__1.maybeAddFunctions,
    maybeAddIterator = $__1.maybeAddIterator,
    registerPolyfill = $__1.registerPolyfill,
    toInteger = $__1.toInteger,
    toLength = $__1.toLength,
    toObject = $__1.toObject;
function from(arrLike) {
  var mapFn = arguments[1];
  var thisArg = arguments[2];
  var C = this;
  var items = toObject(arrLike);
  var mapping = mapFn !== undefined;
  var k = 0;
  var arr,
      len;
  if (mapping && !isCallable(mapFn)) {
    throw TypeError();
  }
  if (checkIterable(items)) {
    arr = isConstructor(C) ? new C() : [];
    for (var $__2 = items[$traceurRuntime.toProperty(Symbol.iterator)](),
        $__3; !($__3 = $__2.next()).done; ) {
      var item = $__3.value;
      {
        if (mapping) {
          arr[k] = mapFn.call(thisArg, item, k);
        } else {
          arr[k] = item;
        }
        k++;
      }
    }
    arr.length = k;
    return arr;
  }
  len = toLength(items.length);
  arr = isConstructor(C) ? new C(len) : new Array(len);
  for (; k < len; k++) {
    if (mapping) {
      arr[k] = typeof thisArg === 'undefined' ? mapFn(items[k], k) : mapFn.call(thisArg, items[k], k);
    } else {
      arr[k] = items[k];
    }
  }
  arr.length = len;
  return arr;
}
function of() {
  for (var items = [],
      $__4 = 0; $__4 < arguments.length; $__4++)
    items[$__4] = arguments[$__4];
  var C = this;
  var len = items.length;
  var arr = isConstructor(C) ? new C(len) : new Array(len);
  for (var k = 0; k < len; k++) {
    arr[k] = items[k];
  }
  arr.length = len;
  return arr;
}
function fill(value) {
  var start = arguments[1] !== (void 0) ? arguments[1] : 0;
  var end = arguments[2];
  var object = toObject(this);
  var len = toLength(object.length);
  var fillStart = toInteger(start);
  var fillEnd = end !== undefined ? toInteger(end) : len;
  fillStart = fillStart < 0 ? Math.max(len + fillStart, 0) : Math.min(fillStart, len);
  fillEnd = fillEnd < 0 ? Math.max(len + fillEnd, 0) : Math.min(fillEnd, len);
  while (fillStart < fillEnd) {
    object[fillStart] = value;
    fillStart++;
  }
  return object;
}
function find(predicate) {
  var thisArg = arguments[1];
  return findHelper(this, predicate, thisArg);
}
function findIndex(predicate) {
  var thisArg = arguments[1];
  return findHelper(this, predicate, thisArg, true);
}
function findHelper(self, predicate) {
  var thisArg = arguments[2];
  var returnIndex = arguments[3] !== (void 0) ? arguments[3] : false;
  var object = toObject(self);
  var len = toLength(object.length);
  if (!isCallable(predicate)) {
    throw TypeError();
  }
  for (var i = 0; i < len; i++) {
    var value = object[i];
    if (predicate.call(thisArg, value, i, object)) {
      return returnIndex ? i : value;
    }
  }
  return returnIndex ? -1 : undefined;
}
function polyfillArray(global) {
  var $__5 = global,
      Array = $__5.Array,
      Object = $__5.Object,
      Symbol = $__5.Symbol;
  maybeAddFunctions(Array.prototype, ['entries', entries, 'keys', keys, 'values', values, 'fill', fill, 'find', find, 'findIndex', findIndex]);
  maybeAddFunctions(Array, ['from', from, 'of', of]);
  maybeAddIterator(Array.prototype, values, Symbol);
  maybeAddIterator(Object.getPrototypeOf([].values()), function() {
    return this;
  }, Symbol);
}
registerPolyfill(polyfillArray);
return {
  get from() {
    return from;
  },
  get of() {
    return of;
  },
  get fill() {
    return fill;
  },
  get find() {
    return find;
  },
  get findIndex() {
    return findIndex;
  },
  get polyfillArray() {
    return polyfillArray;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Array” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Object”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Object";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Object", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    maybeAddFunctions = $__0.maybeAddFunctions,
    registerPolyfill = $__0.registerPolyfill;
var $__1 = $traceurRuntime,
    defineProperty = $__1.defineProperty,
    getOwnPropertyDescriptor = $__1.getOwnPropertyDescriptor,
    getOwnPropertyNames = $__1.getOwnPropertyNames,
    isPrivateName = $__1.isPrivateName,
    keys = $__1.keys;
function is(left, right) {
  if (left === right)
    return left !== 0 || 1 / left === 1 / right;
  return left !== left && right !== right;
}
function assign(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];
    var props = source == null ? [] : keys(source);
    var p,
        length = props.length;
    for (p = 0; p < length; p++) {
      var name = props[p];
      if (isPrivateName(name))
        continue;
      target[name] = source[name];
    }
  }
  return target;
}
function mixin(target, source) {
  var props = getOwnPropertyNames(source);
  var p,
      descriptor,
      length = props.length;
  for (p = 0; p < length; p++) {
    var name = props[p];
    if (isPrivateName(name))
      continue;
    descriptor = getOwnPropertyDescriptor(source, props[p]);
    defineProperty(target, props[p], descriptor);
  }
  return target;
}
function polyfillObject(global) {
  var Object = global.Object;
  maybeAddFunctions(Object, ['assign', assign, 'is', is, 'mixin', mixin]);
}
registerPolyfill(polyfillObject);
return {
  get is() {
    return is;
  },
  get assign() {
    return assign;
  },
  get mixin() {
    return mixin;
  },
  get polyfillObject() {
    return polyfillObject;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Object” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/Number”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/Number";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/Number", path);
}
var $__0 = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils"),
    isNumber = $__0.isNumber,
    maybeAddConsts = $__0.maybeAddConsts,
    maybeAddFunctions = $__0.maybeAddFunctions,
    registerPolyfill = $__0.registerPolyfill,
    toInteger = $__0.toInteger;
var $abs = Math.abs;
var $isFinite = isFinite;
var $isNaN = isNaN;
var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
var MIN_SAFE_INTEGER = -Math.pow(2, 53) + 1;
var EPSILON = Math.pow(2, -52);
function NumberIsFinite(number) {
  return isNumber(number) && $isFinite(number);
}
;
function isInteger(number) {
  return NumberIsFinite(number) && toInteger(number) === number;
}
function NumberIsNaN(number) {
  return isNumber(number) && $isNaN(number);
}
;
function isSafeInteger(number) {
  if (NumberIsFinite(number)) {
    var integral = toInteger(number);
    if (integral === number)
      return $abs(integral) <= MAX_SAFE_INTEGER;
  }
  return false;
}
function polyfillNumber(global) {
  var Number = global.Number;
  maybeAddConsts(Number, ['MAX_SAFE_INTEGER', MAX_SAFE_INTEGER, 'MIN_SAFE_INTEGER', MIN_SAFE_INTEGER, 'EPSILON', EPSILON]);
  maybeAddFunctions(Number, ['isFinite', NumberIsFinite, 'isInteger', isInteger, 'isNaN', NumberIsNaN, 'isSafeInteger', isSafeInteger]);
}
registerPolyfill(polyfillNumber);
return {
  get MAX_SAFE_INTEGER() {
    return MAX_SAFE_INTEGER;
  },
  get MIN_SAFE_INTEGER() {
    return MIN_SAFE_INTEGER;
  },
  get EPSILON() {
    return EPSILON;
  },
  get isFinite() {
    return NumberIsFinite;
  },
  get isInteger() {
    return isInteger;
  },
  get isNaN() {
    return NumberIsNaN;
  },
  get isSafeInteger() {
    return isSafeInteger;
  },
  get polyfillNumber() {
    return polyfillNumber;
  }
};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/Number” + ''); System.register(“traceur-runtime@0.0.74/src/runtime/polyfills/polyfills”, [], function() {

"use strict";
var __moduleName = "traceur-runtime@0.0.74/src/runtime/polyfills/polyfills";
function require(path) {
  return $traceurRuntime.require("traceur-runtime@0.0.74/src/runtime/polyfills/polyfills", path);
}
var polyfillAll = System.get("traceur-runtime@0.0.74/src/runtime/polyfills/utils").polyfillAll;
polyfillAll(this);
var setupGlobals = $traceurRuntime.setupGlobals;
$traceurRuntime.setupGlobals = function(global) {
  setupGlobals(global);
  polyfillAll(global);
};
return {};

}); System.get(“traceur-runtime@0.0.74/src/runtime/polyfills/polyfills” + '');