Generated from https://github.com/Respo/respo with `:advanced :whitespace`

main.js

if (typeof Math.imul == 'undefined' || Math.imul(0xffffffff, 5) == 0) {
  Math.imul = function(a, b) {
    var ah = a >>> 16 & 0xffff;
    var al = a & 0xffff;
    var bh = b >>> 16 & 0xffff;
    var bl = b & 0xffff;
    // the shift by 0 fixes the sign on the high part
    // the final |0 converts the unsigned value into a signed value
    return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;
  };
}

var CLOSURE_NO_DEPS = true;
var COMPILED = false;
var goog = goog || {};
goog.global = this;
goog.global.CLOSURE_UNCOMPILED_DEFINES;
goog.global.CLOSURE_DEFINES;
goog.isDef = function(val) {
  return val !== void 0;
};
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split('.');
  var cur = opt_objectToExportTo || goog.global;
  if (!(parts[0] in cur) && cur.execScript) cur.execScript('var ' + parts[0]);
  for (var part; parts.length && (part = parts.shift()); )
    if (!parts.length && goog.isDef(opt_object)) cur[part] = opt_object;
    else if (cur[part]) cur = cur[part];
    else cur = (cur[part] = {});
};
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED)
    if (
      goog.global.CLOSURE_UNCOMPILED_DEFINES &&
      Object.prototype.hasOwnProperty.call(
        goog.global.CLOSURE_UNCOMPILED_DEFINES,
        name
      )
    )
      value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
    else if (
      goog.global.CLOSURE_DEFINES &&
      Object.prototype.hasOwnProperty.call(goog.global.CLOSURE_DEFINES, name)
    )
      value = goog.global.CLOSURE_DEFINES[name];
  goog.exportPath_(name, value);
};
goog.define('goog.DEBUG', true);
goog.define('goog.LOCALE', 'en');
goog.define('goog.TRUSTED_SITE', true);
goog.define('goog.STRICT_MODE_COMPATIBLE', false);
goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);
goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);
goog.provide = function(name) {
  if (goog.isInModuleLoader_())
    throw Error('goog.provide can not be used within a goog.module.');
  if (!COMPILED)
    if (goog.isProvided_(name))
      throw Error('Namespace "' + name + '" already declared.');
  goog.constructNamespace_(name);
};
goog.constructNamespace_ = function(name, opt_obj) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];
    var namespace = name;
    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
      if (goog.getObjectByName(namespace)) break;
      goog.implicitNamespaces_[namespace] = true;
    }
  }
  goog.exportPath_(name, opt_obj);
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function(name) {
  if (!goog.isString(name) || !name || name.search(goog.VALID_MODULE_RE_) == -1)
    throw Error('Invalid module identifier');
  if (!goog.isInModuleLoader_())
    throw Error('Module ' + name + ' has been loaded incorrectly.');
  if (goog.moduleLoaderState_.moduleName)
    throw Error('goog.module may only be called once per module.');
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    if (goog.isProvided_(name))
      throw Error('Namespace "' + name + '" already declared.');
    delete goog.implicitNamespaces_[name];
  }
};
goog.module.get = function(name) {
  return goog.module.getInternal_(name);
};
goog.module.getInternal_ = function(name) {
  if (!COMPILED)
    if (goog.isProvided_(name))
      return name in goog.loadedModules_
        ? goog.loadedModules_[name]
        : goog.getObjectByName(name);
    else
      return null;
};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
  return goog.moduleLoaderState_ != null;
};
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInModuleLoader_())
    throw new Error(
      'goog.module.declareLegacyNamespace must be called from ' +
        'within a goog.module'
    );
  if (!COMPILED && !goog.moduleLoaderState_.moduleName)
    throw Error(
      'goog.module must be called prior to ' +
        'goog.module.declareLegacyNamespace.'
    );
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || '';
    throw Error(
      'Importing test-only code into non-debug environment' +
        (opt_message ? ': ' + opt_message : '.')
    );
  }
};
goog.forwardDeclare = function(name) {};
goog.forwardDeclare('Document');
goog.forwardDeclare('HTMLScriptElement');
goog.forwardDeclare('XMLHttpRequest');
if (!COMPILED) {
  goog.isProvided_ = function(name) {
    return name in goog.loadedModules_ ||
      (!goog.implicitNamespaces_[name] &&
        goog.isDefAndNotNull(goog.getObjectByName(name)));
  };
  goog.implicitNamespaces_ = { 'goog.module': true };
}
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split('.');
  var cur = opt_obj || goog.global;
  for (var part; (part = parts.shift()); )
    if (goog.isDefAndNotNull(cur[part])) cur = cur[part];
    else return null;
  return cur;
};
goog.globalize = function(obj, opt_global) {
  var global = opt_global || goog.global;
  for (var x in obj)
    global[x] = obj[x];
};
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (goog.DEPENDENCIES_ENABLED) {
    var provide, require;
    var path = relPath.replace(/\\/g, '/');
    var deps = goog.dependencies_;
    if (!opt_loadFlags || typeof opt_loadFlags === 'boolean')
      opt_loadFlags = opt_loadFlags ? { module: 'goog' } : {};
    for (var i = 0; (provide = provides[i]); i++) {
      deps.nameToPath[provide] = path;
      deps.loadFlags[path] = opt_loadFlags;
    }
    for (var j = 0; (require = requires[j]); j++) {
      if (!(path in deps.requires)) deps.requires[path] = {};
      deps.requires[path][require] = true;
    }
  }
};
goog.define('goog.ENABLE_DEBUG_LOADER', true);
goog.logToConsole_ = function(msg) {
  if (goog.global.console) goog.global.console['error'](msg);
};
goog.require = function(name) {
  if (!COMPILED) {
    if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_)
      goog.maybeProcessDeferredDep_(name);
    if (goog.isProvided_(name))
      if (goog.isInModuleLoader_()) return goog.module.getInternal_(name);
      else return null;
    if (goog.ENABLE_DEBUG_LOADER) {
      var path = goog.getPathFromDeps_(name);
      if (path) {
        goog.writeScripts_(path);
        return null;
      }
    }
    var errorMessage = 'goog.require could not find: ' + name;
    goog.logToConsole_(errorMessage);
    throw Error(errorMessage);
  }
};
goog.basePath = '';
goog.global.CLOSURE_BASE_PATH;
goog.global.CLOSURE_NO_DEPS;
goog.global.CLOSURE_IMPORT_SCRIPT;
goog.nullFunction = function() {};
goog.abstractMethod = function() {
  throw Error('unimplemented abstract method');
};
goog.addSingletonGetter = function(ctor) {
  ctor.getInstance = function() {
    if (ctor.instance_) return ctor.instance_;
    if (goog.DEBUG)
      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
    return (ctor.instance_ = new ctor());
  };
};
goog.instantiatedSingletons_ = [];
goog.define('goog.LOAD_MODULE_USING_EVAL', true);
goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;
goog.define('goog.TRANSPILE', 'detect');
goog.define('goog.TRANSPILER', 'transpile.js');
if (goog.DEPENDENCIES_ENABLED) {
  goog.dependencies_ = {
    loadFlags: {},
    nameToPath: {},
    requires: {},
    visited: {},
    written: {},
    deferred: {}
  };
  goog.inHtmlDocument_ = function() {
    var doc = goog.global.document;
    return doc != null && 'write' in doc;
  };
  goog.findBasePath_ = function() {
    if (goog.isDef(goog.global.CLOSURE_BASE_PATH)) {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else if (!goog.inHtmlDocument_()) return;
    var doc = goog.global.document;
    var scripts = doc.getElementsByTagName('SCRIPT');
    for (var i = scripts.length - 1; i >= 0; --i) {
      var script = scripts[i];
      var src = script.src;
      var qmark = src.lastIndexOf('?');
      var l = qmark == -1 ? src.length : qmark;
      if (src.substr(l - 7, 7) == 'base.js') {
        goog.basePath = src.substr(0, l - 7);
        return;
      }
    }
  };
  goog.importScript_ = function(src, opt_sourceText) {
    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
      goog.writeScriptTag_;
    if (importScript(src, opt_sourceText))
      goog.dependencies_.written[src] = true;
  };
  goog.IS_OLD_IE_ = !!(!goog.global.atob &&
    goog.global.document &&
    goog.global.document.all);
  goog.importProcessedScript_ = function(src, isModule, needsTranspile) {
    var bootstrap = 'goog.retrieveAndExec_("' +
      src +
      '", ' +
      isModule +
      ', ' +
      needsTranspile +
      ');';
    goog.importScript_('', bootstrap);
  };
  goog.queuedModules_ = [];
  goog.wrapModule_ = function(srcUrl, scriptText) {
    if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON))
      return '' +
        'goog.loadModule(function(exports) {' +
        '"use strict";' +
        scriptText +
        '\n' +
        ';return exports' +
        '});' +
        '\n//# sourceURL\x3d' +
        srcUrl +
        '\n';
    else
      return '' +
        'goog.loadModule(' +
        goog.global.JSON.stringify(
          scriptText + '\n//# sourceURL\x3d' + srcUrl + '\n'
        ) +
        ');';
  };
  goog.loadQueuedModules_ = function() {
    var count = goog.queuedModules_.length;
    if (count > 0) {
      var queue = goog.queuedModules_;
      goog.queuedModules_ = [];
      for (var i = 0; i < count; i++) {
        var path = queue[i];
        goog.maybeProcessDeferredPath_(path);
      }
    }
  };
  goog.maybeProcessDeferredDep_ = function(name) {
    if (goog.isDeferredModule_(name) && goog.allDepsAreAvailable_(name)) {
      var path = goog.getPathFromDeps_(name);
      goog.maybeProcessDeferredPath_(goog.basePath + path);
    }
  };
  goog.isDeferredModule_ = function(name) {
    var path = goog.getPathFromDeps_(name);
    var loadFlags = (path && goog.dependencies_.loadFlags[path]) || {};
    if (
      path &&
      (loadFlags['module'] == 'goog' || goog.needsTranspile_(loadFlags['lang']))
    ) {
      var abspath = goog.basePath + path;
      return abspath in goog.dependencies_.deferred;
    }
    return false;
  };
  goog.allDepsAreAvailable_ = function(name) {
    var path = goog.getPathFromDeps_(name);
    if (path && path in goog.dependencies_.requires)
      for (var requireName in goog.dependencies_.requires[path])
        if (
          !goog.isProvided_(requireName) && !goog.isDeferredModule_(requireName)
        )
          return false;
    return true;
  };
  goog.maybeProcessDeferredPath_ = function(abspath) {
    if (abspath in goog.dependencies_.deferred) {
      var src = goog.dependencies_.deferred[abspath];
      delete goog.dependencies_.deferred[abspath];
      goog.globalEval(src);
    }
  };
  goog.loadModuleFromUrl = function(url) {
    goog.retrieveAndExec_(url, true, false);
  };
  goog.loadModule = function(moduleDef) {
    var previousState = goog.moduleLoaderState_;
    try {
      goog.moduleLoaderState_ = {
        moduleName: undefined,
        declareLegacyNamespace: false
      };
      var exports;
      if (goog.isFunction(moduleDef)) exports = moduleDef.call(goog.global, {});
      else if (goog.isString(moduleDef))
        exports = goog.loadModuleFromSource_.call(goog.global, moduleDef);
      else
        throw Error('Invalid module definition');
      var moduleName = goog.moduleLoaderState_.moduleName;
      if (!goog.isString(moduleName) || !moduleName)
        throw Error('Invalid module name "' + moduleName + '"');
      if (goog.moduleLoaderState_.declareLegacyNamespace)
        goog.constructNamespace_(moduleName, exports);
      else if (goog.SEAL_MODULE_EXPORTS && Object.seal) Object.seal(exports);
      goog.loadedModules_[moduleName] = exports;
    } finally {
      goog.moduleLoaderState_ = previousState;
    }
  };
  goog.loadModuleFromSource_ = function() {
    var exports = {};
    eval(arguments[0]);
    return exports;
  };
  goog.writeScriptSrcNode_ = function(src) {
    goog.global.document.write(
      '\x3cscript type\x3d"text/javascript" src\x3d"' +
        src +
        '"\x3e\x3c/' +
        'script\x3e'
    );
  };
  goog.appendScriptSrcNode_ = function(src) {
    var doc = goog.global.document;
    var scriptEl = doc.createElement('script');
    scriptEl.type = 'text/javascript';
    scriptEl.src = src;
    scriptEl.defer = false;
    scriptEl.async = false;
    doc.head.appendChild(scriptEl);
  };
  goog.writeScriptTag_ = function(src, opt_sourceText) {
    if (goog.inHtmlDocument_()) {
      var doc = goog.global.document;
      if (
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
        doc.readyState == 'complete'
      ) {
        var isDeps = /\bdeps.js$/.test(src);
        if (isDeps) return false;
        else throw Error('Cannot write "' + src + '" after document load');
      }
      if (opt_sourceText === undefined)
        if (!goog.IS_OLD_IE_)
          if (goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING)
            goog.appendScriptSrcNode_(src);
          else
            goog.writeScriptSrcNode_(src);
        else {
          var state = " onreadystatechange\x3d'goog.onScriptLoad_(this, " +
            ++goog.lastNonModuleScriptIndex_ +
            ")' ";
          doc.write(
            '\x3cscript type\x3d"text/javascript" src\x3d"' +
              src +
              '"' +
              state +
              '\x3e\x3c/' +
              'script\x3e'
          );
        }
      else
        doc.write(
          '\x3cscript type\x3d"text/javascript"\x3e' +
            opt_sourceText +
            '\x3c/' +
            'script\x3e'
        );
      return true;
    } else
      return false;
  };
  goog.needsTranspile_ = function(lang) {
    if (goog.TRANSPILE == 'always')
      return true;
    else if (goog.TRANSPILE == 'never')
      return false;
    else if (!goog.transpiledLanguages_) {
      goog.transpiledLanguages_ = { es5: true, es6: true, 'es6-impl': true };
      try {
        goog.transpiledLanguages_['es5'] = eval('[1,].length!\x3d1');
        var es6implTest = 'let a\x3d{};const X\x3dclass{constructor(){}x(z){return new Map([' +
          '...arguments]).get(z[0])\x3d\x3d3}};return new X().x([a,3])';
        var es6fullTest = 'class X{constructor(){if(new.target!\x3dString)throw 1;this.x\x3d42}}' +
          'let q\x3dReflect.construct(X,[],String);if(q.x!\x3d42||!(q instanceof ' +
          'String))throw 1;for(const a of[2,3]){if(a\x3d\x3d2)continue;function ' +
          'f(z\x3d{a}){let a\x3d0;return z.a}{function f(){return 0;}}return f()' +
          '\x3d\x3d3}';
        if (eval('(()\x3d\x3e{"use strict";' + es6implTest + '})()'))
          goog.transpiledLanguages_['es6-impl'] = false;
        if (eval('(()\x3d\x3e{"use strict";' + es6fullTest + '})()'))
          goog.transpiledLanguages_['es6'] = false;
      } catch (err) {}
    }
    return !!goog.transpiledLanguages_[lang];
  };
  goog.transpiledLanguages_ = null;
  goog.lastNonModuleScriptIndex_ = 0;
  goog.onScriptLoad_ = function(script, scriptIndex) {
    if (
      script.readyState == 'complete' &&
      goog.lastNonModuleScriptIndex_ == scriptIndex
    )
      goog.loadQueuedModules_();
    return true;
  };
  goog.writeScripts_ = function(pathToLoad) {
    var scripts = [];
    var seenScript = {};
    var deps = goog.dependencies_;
    function visitNode(path) {
      if (path in deps.written) return;
      if (path in deps.visited) return;
      deps.visited[path] = true;
      if (path in deps.requires)
        for (var requireName in deps.requires[path])
          if (!goog.isProvided_(requireName))
            if (requireName in deps.nameToPath)
              visitNode(deps.nameToPath[requireName]);
            else
              throw Error('Undefined nameToPath for ' + requireName);
      if (!(path in seenScript)) {
        seenScript[path] = true;
        scripts.push(path);
      }
    }
    visitNode(pathToLoad);
    for (var i = 0; i < scripts.length; i++) {
      var path = scripts[i];
      goog.dependencies_.written[path] = true;
    }
    var moduleState = goog.moduleLoaderState_;
    goog.moduleLoaderState_ = null;
    for (var i = 0; i < scripts.length; i++) {
      var path = scripts[i];
      if (path) {
        var loadFlags = deps.loadFlags[path] || {};
        var needsTranspile = goog.needsTranspile_(loadFlags['lang']);
        if (loadFlags['module'] == 'goog' || needsTranspile)
          goog.importProcessedScript_(
            goog.basePath + path,
            loadFlags['module'] == 'goog',
            needsTranspile
          );
        else
          goog.importScript_(goog.basePath + path);
      } else {
        goog.moduleLoaderState_ = moduleState;
        throw Error('Undefined script input');
      }
    }
    goog.moduleLoaderState_ = moduleState;
  };
  goog.getPathFromDeps_ = function(rule) {
    if (rule in goog.dependencies_.nameToPath)
      return goog.dependencies_.nameToPath[rule];
    else
      return null;
  };
  goog.findBasePath_();
  if (!goog.global.CLOSURE_NO_DEPS)
    goog.importScript_(goog.basePath + 'deps.js');
}
goog.normalizePath_ = function(path) {
  var components = path.split('/');
  var i = 0;
  while (i < components.length)
    if (components[i] == '.') components.splice(i, 1);
    else if (
      i &&
      components[i] == '..' &&
      components[i - 1] &&
      components[i - 1] != '..'
    )
      components.splice(--i, 2);
    else
      i++;
  return components.join('/');
};
goog.loadFileSync_ = function(src) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC)
    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
  else
    try {
      var xhr = new goog.global['XMLHttpRequest']();
      xhr.open('get', src, false);
      xhr.send();
      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
    } catch (err) {
      return null;
    }
};
goog.retrieveAndExec_ = function(src, isModule, needsTranspile) {
  if (!COMPILED) {
    var originalPath = src;
    src = goog.normalizePath_(src);
    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
      goog.writeScriptTag_;
    var scriptText = goog.loadFileSync_(src);
    if (scriptText == null) throw new Error('Load of "' + src + '" failed');
    if (needsTranspile)
      scriptText = goog.transpile_.call(goog.global, scriptText, src);
    if (isModule) scriptText = goog.wrapModule_(src, scriptText);
    else scriptText += '\n//# sourceURL\x3d' + src;
    var isOldIE = goog.IS_OLD_IE_;
    if (isOldIE) {
      goog.dependencies_.deferred[originalPath] = scriptText;
      goog.queuedModules_.push(originalPath);
    } else
      importScript(src, scriptText);
  }
};
goog.transpile_ = function(code, path) {
  var jscomp = goog.global['$jscomp'];
  if (!jscomp) goog.global['$jscomp'] = (jscomp = {});
  var transpile = jscomp.transpile;
  if (!transpile) {
    var transpilerPath = goog.basePath + goog.TRANSPILER;
    var transpilerCode = goog.loadFileSync_(transpilerPath);
    if (transpilerCode) {
      eval(transpilerCode + '\n//# sourceURL\x3d' + transpilerPath);
      jscomp = goog.global['$jscomp'];
      transpile = jscomp.transpile;
    }
  }
  if (!transpile) {
    var suffix = ' requires transpilation but no transpiler was found.';
    transpile = (jscomp.transpile = function(code, path) {
      goog.logToConsole_(path + suffix);
      return code;
    });
  }
  return transpile(code, path);
};
goog.typeOf = function(value) {
  var s = typeof value;
  if (s == 'object')
    if (value) {
      if (value instanceof Array) return 'array';
      else if (value instanceof Object) return s;
      var className = Object.prototype.toString.call(value);
      if (className == '[object Window]') return 'object';
      if (
        className == '[object Array]' ||
        (typeof value.length == 'number' &&
          typeof value.splice != 'undefined' &&
          typeof value.propertyIsEnumerable != 'undefined' &&
          !value.propertyIsEnumerable('splice'))
      )
        return 'array';
      if (
        className == '[object Function]' ||
        (typeof value.call != 'undefined' &&
          typeof value.propertyIsEnumerable != 'undefined' &&
          !value.propertyIsEnumerable('call'))
      )
        return 'function';
    } else
      return 'null';
  else if (s == 'function' && typeof value.call == 'undefined') return 'object';
  return s;
};
goog.isNull = function(val) {
  return val === null;
};
goog.isDefAndNotNull = function(val) {
  return val != null;
};
goog.isArray = function(val) {
  return goog.typeOf(val) == 'array';
};
goog.isArrayLike = function(val) {
  var type = goog.typeOf(val);
  return type == 'array' || (type == 'object' && typeof val.length == 'number');
};
goog.isDateLike = function(val) {
  return goog.isObject(val) && typeof val.getFullYear == 'function';
};
goog.isString = function(val) {
  return typeof val == 'string';
};
goog.isBoolean = function(val) {
  return typeof val == 'boolean';
};
goog.isNumber = function(val) {
  return typeof val == 'number';
};
goog.isFunction = function(val) {
  return goog.typeOf(val) == 'function';
};
goog.isObject = function(val) {
  var type = typeof val;
  return (type == 'object' && val != null) || type == 'function';
};
goog.getUid = function(obj) {
  return obj[goog.UID_PROPERTY_] ||
    (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};
goog.hasUid = function(obj) {
  return !!obj[goog.UID_PROPERTY_];
};
goog.removeUid = function(obj) {
  if (obj !== null && 'removeAttribute' in obj)
    obj.removeAttribute(goog.UID_PROPERTY_);
  try {
    delete obj[goog.UID_PROPERTY_];
  } catch (ex) {}
};
goog.UID_PROPERTY_ = 'closure_uid_' + (Math.random() * 1e9 >>> 0);
goog.uidCounter_ = 0;
goog.getHashCode = goog.getUid;
goog.removeHashCode = goog.removeUid;
goog.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == 'object' || type == 'array') {
    if (obj.clone) return obj.clone();
    var clone = type == 'array' ? [] : {};
    for (var key in obj)
      clone[key] = goog.cloneObject(obj[key]);
    return clone;
  }
  return obj;
};
goog.bindNative_ = function(fn, selfObj, var_args) {
  return fn.call.apply(fn.bind, arguments);
};
goog.bindJs_ = function(fn, selfObj, var_args) {
  if (!fn) throw new Error();
  if (arguments.length > 2) {
    var boundArgs = Array.prototype.slice.call(arguments, 2);
    return function() {
      var newArgs = Array.prototype.slice.call(arguments);
      Array.prototype.unshift.apply(newArgs, boundArgs);
      return fn.apply(selfObj, newArgs);
    };
  } else
    return function() {
      return fn.apply(selfObj, arguments);
    };
};
goog.bind = function(fn, selfObj, var_args) {
  if (
    Function.prototype.bind &&
    Function.prototype.bind.toString().indexOf('native code') != -1
  )
    goog.bind = goog.bindNative_;
  else
    goog.bind = goog.bindJs_;
  return goog.bind.apply(null, arguments);
};
goog.partial = function(fn, var_args) {
  var args = Array.prototype.slice.call(arguments, 1);
  return function() {
    var newArgs = args.slice();
    newArgs.push.apply(newArgs, arguments);
    return fn.apply(this, newArgs);
  };
};
goog.mixin = function(target, source) {
  for (var x in source)
    target[x] = source[x];
};
goog.now = (goog.TRUSTED_SITE && Date.now) ||
  function() {
    return +new Date();
  };
goog.globalEval = function(script) {
  if (goog.global.execScript)
    goog.global.execScript(script, 'JavaScript');
  else if (goog.global.eval) {
    if (goog.evalWorksForGlobals_ == null) {
      goog.global.eval('var _evalTest_ \x3d 1;');
      if (typeof goog.global['_evalTest_'] != 'undefined') {
        try {
          delete goog.global['_evalTest_'];
        } catch (ignore) {}
        goog.evalWorksForGlobals_ = true;
      } else
        goog.evalWorksForGlobals_ = false;
    }
    if (goog.evalWorksForGlobals_)
      goog.global.eval(script);
    else {
      var doc = goog.global.document;
      var scriptElt = doc.createElement('SCRIPT');
      scriptElt.type = 'text/javascript';
      scriptElt.defer = false;
      scriptElt.appendChild(doc.createTextNode(script));
      doc.body.appendChild(scriptElt);
      doc.body.removeChild(scriptElt);
    }
  } else
    throw Error('goog.globalEval not available');
};
goog.evalWorksForGlobals_ = null;
goog.cssNameMapping_;
goog.cssNameMappingStyle_;
goog.getCssName = function(className, opt_modifier) {
  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };
  var renameByParts = function(cssName) {
    var parts = cssName.split('-');
    var mapped = [];
    for (var i = 0; i < parts.length; i++)
      mapped.push(getMapping(parts[i]));
    return mapped.join('-');
  };
  var rename;
  if (goog.cssNameMapping_)
    rename = goog.cssNameMappingStyle_ == 'BY_WHOLE'
      ? getMapping
      : renameByParts;
  else
    rename = function(a) {
      return a;
    };
  if (opt_modifier) return className + '-' + rename(opt_modifier);
  else return rename(className);
};
goog.setCssNameMapping = function(mapping, opt_style) {
  goog.cssNameMapping_ = mapping;
  goog.cssNameMappingStyle_ = opt_style;
};
goog.global.CLOSURE_CSS_NAME_MAPPING;
if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING)
  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
goog.getMsg = function(str, opt_values) {
  if (opt_values)
    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
      return opt_values != null && key in opt_values ? opt_values[key] : match;
    });
  return str;
};
goog.getMsgWithFallback = function(a, b) {
  return a;
};
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  goog.exportPath_(publicPath, object, opt_objectToExportTo);
};
goog.exportProperty = function(object, publicName, symbol) {
  object[publicName] = symbol;
};
goog.inherits = function(childCtor, parentCtor) {
  function tempCtor() {}
  tempCtor.prototype = parentCtor.prototype;
  childCtor.superClass_ = parentCtor.prototype;
  childCtor.prototype = new tempCtor();
  childCtor.prototype.constructor = childCtor;
  childCtor.base = function(me, methodName, var_args) {
    var args = new Array(arguments.length - 2);
    for (var i = 2; i < arguments.length; i++)
      args[i - 2] = arguments[i];
    return parentCtor.prototype[methodName].apply(me, args);
  };
};
goog.base = function(me, opt_methodName, var_args) {
  var caller = arguments.callee.caller;
  if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller))
    throw Error(
      'arguments.caller not defined.  goog.base() cannot be used ' +
        'with strict mode code. See ' +
        'http://www.ecma-international.org/ecma-262/5.1/#sec-C'
    );
  if (caller.superClass_) {
    var ctorArgs = new Array(arguments.length - 1);
    for (var i = 1; i < arguments.length; i++)
      ctorArgs[i - 1] = arguments[i];
    return caller.superClass_.constructor.apply(me, ctorArgs);
  }
  var args = new Array(arguments.length - 2);
  for (var i = 2; i < arguments.length; i++)
    args[i - 2] = arguments[i];
  var foundCaller = false;
  for (
    var ctor = me.constructor;
    ctor;
    ctor = ctor.superClass_ && ctor.superClass_.constructor
  )
    if (ctor.prototype[opt_methodName] === caller) foundCaller = true;
    else if (foundCaller) return ctor.prototype[opt_methodName].apply(me, args);
  if (me[opt_methodName] === caller)
    return me.constructor.prototype[opt_methodName].apply(me, args);
  else
    throw Error(
      'goog.base called from a method of one name ' +
        'to a method of a different name'
    );
};
goog.scope = function(fn) {
  if (goog.isInModuleLoader_())
    throw Error('goog.scope is not supported within a goog.module.');
  fn.call(goog.global);
};
if (!COMPILED) goog.global['COMPILED'] = COMPILED;
goog.defineClass = function(superClass, def) {
  var constructor = def.constructor;
  var statics = def.statics;
  if (!constructor || constructor == Object.prototype.constructor)
    constructor = function() {
      throw Error('cannot instantiate an interface (no constructor defined).');
    };
  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
  if (superClass) goog.inherits(cls, superClass);
  delete def.constructor;
  delete def.statics;
  goog.defineClass.applyProperties_(cls.prototype, def);
  if (statics != null) if (statics instanceof Function) statics(cls);
    else goog.defineClass.applyProperties_(cls, statics);
  return cls;
};
goog.defineClass.ClassDescriptor;
goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) return ctr;
  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);
  var wrappedCtr = function() {
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
    if (
      this.constructor === wrappedCtr &&
      superclassSealable &&
      Object.seal instanceof Function
    )
      Object.seal(instance);
    return instance;
  };
  return wrappedCtr;
};
goog.defineClass.isUnsealable_ = function(ctr) {
  return ctr &&
    ctr.prototype &&
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
  'constructor',
  'hasOwnProperty',
  'isPrototypeOf',
  'propertyIsEnumerable',
  'toLocaleString',
  'toString',
  'valueOf'
];
goog.defineClass.applyProperties_ = function(target, source) {
  var key;
  for (key in source)
    if (Object.prototype.hasOwnProperty.call(source, key))
      target[key] = source[key];
  for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
    if (Object.prototype.hasOwnProperty.call(source, key))
      target[key] = source[key];
  }
};
goog.tagUnsealableClass = function(ctr) {
  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES)
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
};
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';
goog.provide('goog.string');
goog.provide('goog.string.Unicode');
goog.define('goog.string.DETECT_DOUBLE_ESCAPING', false);
goog.define('goog.string.FORCE_NON_DOM_HTML_UNESCAPING', false);
goog.string.Unicode = { NBSP: ' ' };
goog.string.startsWith = function(str, prefix) {
  return str.lastIndexOf(prefix, 0) == 0;
};
goog.string.endsWith = function(str, suffix) {
  var l = str.length - suffix.length;
  return l >= 0 && str.indexOf(suffix, l) == l;
};
goog.string.caseInsensitiveStartsWith = function(str, prefix) {
  return goog.string.caseInsensitiveCompare(
    prefix,
    str.substr(0, prefix.length)
  ) == 0;
};
goog.string.caseInsensitiveEndsWith = function(str, suffix) {
  return goog.string.caseInsensitiveCompare(
    suffix,
    str.substr(str.length - suffix.length, suffix.length)
  ) == 0;
};
goog.string.caseInsensitiveEquals = function(str1, str2) {
  return str1.toLowerCase() == str2.toLowerCase();
};
goog.string.subs = function(str, var_args) {
  var splitParts = str.split('%s');
  var returnString = '';
  var subsArguments = Array.prototype.slice.call(arguments, 1);
  while (subsArguments.length && splitParts.length > 1)
    returnString += splitParts.shift() + subsArguments.shift();
  return returnString + splitParts.join('%s');
};
goog.string.collapseWhitespace = function(str) {
  return str.replace(/[\s\xa0]+/g, ' ').replace(/^\s+|\s+$/g, '');
};
goog.string.isEmptyOrWhitespace = function(str) {
  return /^[\s\xa0]*$/.test(str);
};
goog.string.isEmptyString = function(str) {
  return str.length == 0;
};
goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
goog.string.isEmptyOrWhitespaceSafe = function(str) {
  return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
};
goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
goog.string.isBreakingWhitespace = function(str) {
  return !/[^\t\n\r ]/.test(str);
};
goog.string.isAlpha = function(str) {
  return !/[^a-zA-Z]/.test(str);
};
goog.string.isNumeric = function(str) {
  return !/[^0-9]/.test(str);
};
goog.string.isAlphaNumeric = function(str) {
  return !/[^a-zA-Z0-9]/.test(str);
};
goog.string.isSpace = function(ch) {
  return ch == ' ';
};
goog.string.isUnicodeChar = function(ch) {
  return (ch.length == 1 && ch >= ' ' && ch <= '~') || (ch >= '€' && ch <= '�');
};
goog.string.stripNewlines = function(str) {
  return str.replace(/(\r\n|\r|\n)+/g, ' ');
};
goog.string.canonicalizeNewlines = function(str) {
  return str.replace(/(\r\n|\r|\n)/g, '\n');
};
goog.string.normalizeWhitespace = function(str) {
  return str.replace(/\xa0|\s/g, ' ');
};
goog.string.normalizeSpaces = function(str) {
  return str.replace(/\xa0|[ \t]+/g, ' ');
};
goog.string.collapseBreakingSpaces = function(str) {
  return str
    .replace(/[\t\r\n ]+/g, ' ')
    .replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, '');
};
goog.string.trim = goog.TRUSTED_SITE && String.prototype.trim
  ? function(str) {
      return str.trim();
    }
  : function(str) {
      return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
    };
goog.string.trimLeft = function(str) {
  return str.replace(/^[\s\xa0]+/, '');
};
goog.string.trimRight = function(str) {
  return str.replace(/[\s\xa0]+$/, '');
};
goog.string.caseInsensitiveCompare = function(str1, str2) {
  var test1 = String(str1).toLowerCase();
  var test2 = String(str2).toLowerCase();
  if (test1 < test2) return -1;
  else if (test1 == test2) return 0;
  else return 1;
};
goog.string.numberAwareCompare_ = function(str1, str2, tokenizerRegExp) {
  if (str1 == str2) return 0;
  if (!str1) return -1;
  if (!str2) return 1;
  var tokens1 = str1.toLowerCase().match(tokenizerRegExp);
  var tokens2 = str2.toLowerCase().match(tokenizerRegExp);
  var count = Math.min(tokens1.length, tokens2.length);
  for (var i = 0; i < count; i++) {
    var a = tokens1[i];
    var b = tokens2[i];
    if (a != b) {
      var num1 = parseInt(a, 10);
      if (!isNaN(num1)) {
        var num2 = parseInt(b, 10);
        if (!isNaN(num2) && num1 - num2) return num1 - num2;
      }
      return a < b ? -1 : 1;
    }
  }
  if (tokens1.length != tokens2.length) return tokens1.length - tokens2.length;
  return str1 < str2 ? -1 : 1;
};
goog.string.intAwareCompare = function(str1, str2) {
  return goog.string.numberAwareCompare_(str1, str2, /\d+|\D+/g);
};
goog.string.floatAwareCompare = function(str1, str2) {
  return goog.string.numberAwareCompare_(str1, str2, /\d+|\.\d+|\D+/g);
};
goog.string.numerateCompare = goog.string.floatAwareCompare;
goog.string.urlEncode = function(str) {
  return encodeURIComponent(String(str));
};
goog.string.urlDecode = function(str) {
  return decodeURIComponent(str.replace(/\+/g, ' '));
};
goog.string.newLineToBr = function(str, opt_xml) {
  return str.replace(/(\r\n|\r|\n)/g, opt_xml ? '\x3cbr /\x3e' : '\x3cbr\x3e');
};
goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
  if (opt_isLikelyToContainHtmlChars) {
    str = str
      .replace(goog.string.AMP_RE_, '\x26amp;')
      .replace(goog.string.LT_RE_, '\x26lt;')
      .replace(goog.string.GT_RE_, '\x26gt;')
      .replace(goog.string.QUOT_RE_, '\x26quot;')
      .replace(goog.string.SINGLE_QUOTE_RE_, '\x26#39;')
      .replace(goog.string.NULL_RE_, '\x26#0;');
    if (goog.string.DETECT_DOUBLE_ESCAPING)
      str = str.replace(goog.string.E_RE_, '\x26#101;');
    return str;
  } else {
    if (!goog.string.ALL_RE_.test(str)) return str;
    if (str.indexOf('\x26') != -1)
      str = str.replace(goog.string.AMP_RE_, '\x26amp;');
    if (str.indexOf('\x3c') != -1)
      str = str.replace(goog.string.LT_RE_, '\x26lt;');
    if (str.indexOf('\x3e') != -1)
      str = str.replace(goog.string.GT_RE_, '\x26gt;');
    if (str.indexOf('"') != -1)
      str = str.replace(goog.string.QUOT_RE_, '\x26quot;');
    if (str.indexOf("'") != -1)
      str = str.replace(goog.string.SINGLE_QUOTE_RE_, '\x26#39;');
    if (str.indexOf('\x00') != -1)
      str = str.replace(goog.string.NULL_RE_, '\x26#0;');
    if (goog.string.DETECT_DOUBLE_ESCAPING && str.indexOf('e') != -1)
      str = str.replace(goog.string.E_RE_, '\x26#101;');
    return str;
  }
};
goog.string.AMP_RE_ = /&/g;
goog.string.LT_RE_ = /</g;
goog.string.GT_RE_ = />/g;
goog.string.QUOT_RE_ = /"/g;
goog.string.SINGLE_QUOTE_RE_ = /'/g;
goog.string.NULL_RE_ = /\x00/g;
goog.string.E_RE_ = /e/g;
goog.string.ALL_RE_ = goog.string.DETECT_DOUBLE_ESCAPING
  ? /[\x00&<>"'e]/
  : /[\x00&<>"']/;
goog.string.unescapeEntities = function(str) {
  if (goog.string.contains(str, '\x26'))
    if (!goog.string.FORCE_NON_DOM_HTML_UNESCAPING && 'document' in goog.global)
      return goog.string.unescapeEntitiesUsingDom_(str);
    else
      return goog.string.unescapePureXmlEntities_(str);
  return str;
};
goog.string.unescapeEntitiesWithDocument = function(str, document) {
  if (goog.string.contains(str, '\x26'))
    return goog.string.unescapeEntitiesUsingDom_(str, document);
  return str;
};
goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
  var seen = {
    '\x26amp;': '\x26',
    '\x26lt;': '\x3c',
    '\x26gt;': '\x3e',
    '\x26quot;': '"'
  };
  var div;
  if (opt_document) div = opt_document.createElement('div');
  else div = goog.global.document.createElement('div');
  return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
    var value = seen[s];
    if (value) return value;
    if (entity.charAt(0) == '#') {
      var n = Number('0' + entity.substr(1));
      if (!isNaN(n)) value = String.fromCharCode(n);
    }
    if (!value) {
      div.innerHTML = s + ' ';
      value = div.firstChild.nodeValue.slice(0, -1);
    }
    return (seen[s] = value);
  });
};
goog.string.unescapePureXmlEntities_ = function(str) {
  return str.replace(/&([^;]+);/g, function(s, entity) {
    switch (entity) {
      case 'amp':
        return '\x26';
      case 'lt':
        return '\x3c';
      case 'gt':
        return '\x3e';
      case 'quot':
        return '"';
      default:
        if (entity.charAt(0) == '#') {
          var n = Number('0' + entity.substr(1));
          if (!isNaN(n)) return String.fromCharCode(n);
        }
        return s;
    }
  });
};
goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
goog.string.whitespaceEscape = function(str, opt_xml) {
  return goog.string.newLineToBr(str.replace(/  /g, ' \x26#160;'), opt_xml);
};
goog.string.preserveSpaces = function(str) {
  return str.replace(/(^|[\n ]) /g, '$1' + goog.string.Unicode.NBSP);
};
goog.string.stripQuotes = function(str, quoteChars) {
  var length = quoteChars.length;
  for (var i = 0; i < length; i++) {
    var quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i);
    if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar)
      return str.substring(1, str.length - 1);
  }
  return str;
};
goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
  if (opt_protectEscapedCharacters) str = goog.string.unescapeEntities(str);
  if (str.length > chars) str = str.substring(0, chars - 3) + '...';
  if (opt_protectEscapedCharacters) str = goog.string.htmlEscape(str);
  return str;
};
goog.string.truncateMiddle = function(
  str,
  chars,
  opt_protectEscapedCharacters,
  opt_trailingChars
) {
  if (opt_protectEscapedCharacters) str = goog.string.unescapeEntities(str);
  if (opt_trailingChars && str.length > chars) {
    if (opt_trailingChars > chars) opt_trailingChars = chars;
    var endPoint = str.length - opt_trailingChars;
    var startPoint = chars - opt_trailingChars;
    str = str.substring(0, startPoint) + '...' + str.substring(endPoint);
  } else if (str.length > chars) {
    var half = Math.floor(chars / 2);
    var endPos = str.length - half;
    half += chars % 2;
    str = str.substring(0, half) + '...' + str.substring(endPos);
  }
  if (opt_protectEscapedCharacters) str = goog.string.htmlEscape(str);
  return str;
};
goog.string.specialEscapeChars_ = {
  '\x00': '\\0',
  '\b': '\\b',
  '\f': '\\f',
  '\n': '\\n',
  '\r': '\\r',
  '\t': '\\t',
  '\x0B': '\\x0B',
  '"': '\\"',
  '\\': '\\\\',
  '\x3c': '\x3c'
};
goog.string.jsEscapeCache_ = { "'": "\\'" };
goog.string.quote = function(s) {
  s = String(s);
  var sb = ['"'];
  for (var i = 0; i < s.length; i++) {
    var ch = s.charAt(i);
    var cc = ch.charCodeAt(0);
    sb[i + 1] = goog.string.specialEscapeChars_[ch] ||
      (cc > 31 && cc < 127 ? ch : goog.string.escapeChar(ch));
  }
  sb.push('"');
  return sb.join('');
};
goog.string.escapeString = function(str) {
  var sb = [];
  for (var i = 0; i < str.length; i++)
    sb[i] = goog.string.escapeChar(str.charAt(i));
  return sb.join('');
};
goog.string.escapeChar = function(c) {
  if (c in goog.string.jsEscapeCache_) return goog.string.jsEscapeCache_[c];
  if (c in goog.string.specialEscapeChars_)
    return (goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c]);
  var rv = c;
  var cc = c.charCodeAt(0);
  if (cc > 31 && cc < 127)
    rv = c;
  else {
    if (cc < 256) {
      rv = '\\x';
      if (cc < 16 || cc > 256) rv += '0';
    } else {
      rv = '\\u';
      if (cc < 4096) rv += '0';
    }
    rv += cc.toString(16).toUpperCase();
  }
  return (goog.string.jsEscapeCache_[c] = rv);
};
goog.string.contains = function(str, subString) {
  return str.indexOf(subString) != -1;
};
goog.string.caseInsensitiveContains = function(str, subString) {
  return goog.string.contains(str.toLowerCase(), subString.toLowerCase());
};
goog.string.countOf = function(s, ss) {
  return s && ss ? s.split(ss).length - 1 : 0;
};
goog.string.removeAt = function(s, index, stringLength) {
  var resultStr = s;
  if (index >= 0 && index < s.length && stringLength > 0)
    resultStr = s.substr(0, index) +
      s.substr(index + stringLength, s.length - index - stringLength);
  return resultStr;
};
goog.string.remove = function(s, ss) {
  var re = new RegExp(goog.string.regExpEscape(ss), '');
  return s.replace(re, '');
};
goog.string.removeAll = function(s, ss) {
  var re = new RegExp(goog.string.regExpEscape(ss), 'g');
  return s.replace(re, '');
};
goog.string.regExpEscape = function(s) {
  return String(s)
    .replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1')
    .replace(/\x08/g, '\\x08');
};
goog.string.repeat = String.prototype.repeat
  ? function(string, length) {
      return string.repeat(length);
    }
  : function(string, length) {
      return new Array(length + 1).join(string);
    };
goog.string.padNumber = function(num, length, opt_precision) {
  var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num);
  var index = s.indexOf('.');
  if (index == -1) index = s.length;
  return goog.string.repeat('0', Math.max(0, length - index)) + s;
};
goog.string.makeSafe = function(obj) {
  return obj == null ? '' : String(obj);
};
goog.string.buildString = function(var_args) {
  return Array.prototype.join.call(arguments, '');
};
goog.string.getRandomString = function() {
  var x = 2147483648;
  return Math.floor(Math.random() * x).toString(36) +
    Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36);
};
goog.string.compareVersions = function(version1, version2) {
  var order = 0;
  var v1Subs = goog.string.trim(String(version1)).split('.');
  var v2Subs = goog.string.trim(String(version2)).split('.');
  var subCount = Math.max(v1Subs.length, v2Subs.length);
  for (var subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {
    var v1Sub = v1Subs[subIdx] || '';
    var v2Sub = v2Subs[subIdx] || '';
    var v1CompParser = new RegExp('(\\d*)(\\D*)', 'g');
    var v2CompParser = new RegExp('(\\d*)(\\D*)', 'g');
    do {
      var v1Comp = v1CompParser.exec(v1Sub) || ['', '', ''];
      var v2Comp = v2CompParser.exec(v2Sub) || ['', '', ''];
      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) break;
      var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);
      var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
      order = goog.string.compareElements_(v1CompNum, v2CompNum) ||
        goog.string.compareElements_(
          v1Comp[2].length == 0,
          v2Comp[2].length == 0
        ) ||
        goog.string.compareElements_(v1Comp[2], v2Comp[2]);
    } while (order == 0);
  }
  return order;
};
goog.string.compareElements_ = function(left, right) {
  if (left < right) return -1;
  else if (left > right) return 1;
  return 0;
};
goog.string.hashCode = function(str) {
  var result = 0;
  for (var i = 0; i < str.length; ++i)
    result = 31 * result + str.charCodeAt(i) >>> 0;
  return result;
};
goog.string.uniqueStringCounter_ = Math.random() * 2147483648 | 0;
goog.string.createUniqueString = function() {
  return 'goog_' + goog.string.uniqueStringCounter_++;
};
goog.string.toNumber = function(str) {
  var num = Number(str);
  if (num == 0 && goog.string.isEmptyOrWhitespace(str)) return NaN;
  return num;
};
goog.string.isLowerCamelCase = function(str) {
  return /^[a-z]+([A-Z][a-z]*)*$/.test(str);
};
goog.string.isUpperCamelCase = function(str) {
  return /^([A-Z][a-z]*)+$/.test(str);
};
goog.string.toCamelCase = function(str) {
  return String(str).replace(/\-([a-z])/g, function(all, match) {
    return match.toUpperCase();
  });
};
goog.string.toSelectorCase = function(str) {
  return String(str).replace(/([A-Z])/g, '-$1').toLowerCase();
};
goog.string.toTitleCase = function(str, opt_delimiters) {
  var delimiters = goog.isString(opt_delimiters)
    ? goog.string.regExpEscape(opt_delimiters)
    : '\\s';
  delimiters = delimiters ? '|[' + delimiters + ']+' : '';
  var regexp = new RegExp('(^' + delimiters + ')([a-z])', 'g');
  return str.replace(regexp, function(all, p1, p2) {
    return p1 + p2.toUpperCase();
  });
};
goog.string.capitalize = function(str) {
  return String(str.charAt(0)).toUpperCase() +
    String(str.substr(1)).toLowerCase();
};
goog.string.parseInt = function(value) {
  if (isFinite(value)) value = String(value);
  if (goog.isString(value))
    return /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10);
  return NaN;
};
goog.string.splitLimit = function(str, separator, limit) {
  var parts = str.split(separator);
  var returnVal = [];
  while (limit > 0 && parts.length) {
    returnVal.push(parts.shift());
    limit--;
  }
  if (parts.length) returnVal.push(parts.join(separator));
  return returnVal;
};
goog.string.lastComponent = function(str, separators) {
  if (!separators) return str;
  else if (typeof separators == 'string') separators = [separators];
  var lastSeparatorIndex = -1;
  for (var i = 0; i < separators.length; i++) {
    if (separators[i] == '') continue;
    var currentSeparatorIndex = str.lastIndexOf(separators[i]);
    if (currentSeparatorIndex > lastSeparatorIndex)
      lastSeparatorIndex = currentSeparatorIndex;
  }
  if (lastSeparatorIndex == -1) return str;
  return str.slice(lastSeparatorIndex + 1);
};
goog.string.editDistance = function(a, b) {
  var v0 = [];
  var v1 = [];
  if (a == b) return 0;
  if (!a.length || !b.length) return Math.max(a.length, b.length);
  for (var i = 0; i < b.length + 1; i++)
    v0[i] = i;
  for (var i = 0; i < a.length; i++) {
    v1[0] = i + 1;
    for (var j = 0; j < b.length; j++) {
      var cost = Number(a[i] != b[j]);
      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
    }
    for (var j = 0; j < v0.length; j++)
      v0[j] = v1[j];
  }
  return v1[b.length];
};
goog.provide('goog.object');
goog.object.is = function(v, v2) {
  if (v === v2) return v !== 0 || 1 / v === 1 / v2;
  return v !== v && v2 !== v2;
};
goog.object.forEach = function(obj, f, opt_obj) {
  for (var key in obj)
    f.call(opt_obj, obj[key], key, obj);
};
goog.object.filter = function(obj, f, opt_obj) {
  var res = {};
  for (var key in obj)
    if (f.call(opt_obj, obj[key], key, obj)) res[key] = obj[key];
  return res;
};
goog.object.map = function(obj, f, opt_obj) {
  var res = {};
  for (var key in obj)
    res[key] = f.call(opt_obj, obj[key], key, obj);
  return res;
};
goog.object.some = function(obj, f, opt_obj) {
  for (var key in obj)
    if (f.call(opt_obj, obj[key], key, obj)) return true;
  return false;
};
goog.object.every = function(obj, f, opt_obj) {
  for (var key in obj)
    if (!f.call(opt_obj, obj[key], key, obj)) return false;
  return true;
};
goog.object.getCount = function(obj) {
  var rv = 0;
  for (var key in obj)
    rv++;
  return rv;
};
goog.object.getAnyKey = function(obj) {
  for (var key in obj)
    return key;
};
goog.object.getAnyValue = function(obj) {
  for (var key in obj)
    return obj[key];
};
goog.object.contains = function(obj, val) {
  return goog.object.containsValue(obj, val);
};
goog.object.getValues = function(obj) {
  var res = [];
  var i = 0;
  for (var key in obj)
    res[i++] = obj[key];
  return res;
};
goog.object.getKeys = function(obj) {
  var res = [];
  var i = 0;
  for (var key in obj)
    res[i++] = key;
  return res;
};
goog.object.getValueByKeys = function(obj, var_args) {
  var isArrayLike = goog.isArrayLike(var_args);
  var keys = isArrayLike ? var_args : arguments;
  for (var i = isArrayLike ? 0 : 1; i < keys.length; i++) {
    obj = obj[keys[i]];
    if (!goog.isDef(obj)) break;
  }
  return obj;
};
goog.object.containsKey = function(obj, key) {
  return obj !== null && key in obj;
};
goog.object.containsValue = function(obj, val) {
  for (var key in obj)
    if (obj[key] == val) return true;
  return false;
};
goog.object.findKey = function(obj, f, opt_this) {
  for (var key in obj)
    if (f.call(opt_this, obj[key], key, obj)) return key;
  return undefined;
};
goog.object.findValue = function(obj, f, opt_this) {
  var key = goog.object.findKey(obj, f, opt_this);
  return key && obj[key];
};
goog.object.isEmpty = function(obj) {
  for (var key in obj)
    return false;
  return true;
};
goog.object.clear = function(obj) {
  for (var i in obj)
    delete obj[i];
};
goog.object.remove = function(obj, key) {
  var rv;
  if ((rv = key in obj)) delete obj[key];
  return rv;
};
goog.object.add = function(obj, key, val) {
  if (obj !== null && key in obj)
    throw Error('The object already contains the key "' + key + '"');
  goog.object.set(obj, key, val);
};
goog.object.get = function(obj, key, opt_val) {
  if (obj !== null && key in obj) return obj[key];
  return opt_val;
};
goog.object.set = function(obj, key, value) {
  obj[key] = value;
};
goog.object.setIfUndefined = function(obj, key, value) {
  return key in obj ? obj[key] : (obj[key] = value);
};
goog.object.setWithReturnValueIfNotSet = function(obj, key, f) {
  if (key in obj) return obj[key];
  var val = f();
  obj[key] = val;
  return val;
};
goog.object.equals = function(a, b) {
  for (var k in a)
    if (!(k in b) || a[k] !== b[k]) return false;
  for (var k in b)
    if (!(k in a)) return false;
  return true;
};
goog.object.clone = function(obj) {
  var res = {};
  for (var key in obj)
    res[key] = obj[key];
  return res;
};
goog.object.unsafeClone = function(obj) {
  var type = goog.typeOf(obj);
  if (type == 'object' || type == 'array') {
    if (goog.isFunction(obj.clone)) return obj.clone();
    var clone = type == 'array' ? [] : {};
    for (var key in obj)
      clone[key] = goog.object.unsafeClone(obj[key]);
    return clone;
  }
  return obj;
};
goog.object.transpose = function(obj) {
  var transposed = {};
  for (var key in obj)
    transposed[obj[key]] = key;
  return transposed;
};
goog.object.PROTOTYPE_FIELDS_ = [
  'constructor',
  'hasOwnProperty',
  'isPrototypeOf',
  'propertyIsEnumerable',
  'toLocaleString',
  'toString',
  'valueOf'
];
goog.object.extend = function(target, var_args) {
  var key, source;
  for (var i = 1; i < arguments.length; i++) {
    source = arguments[i];
    for (key in source)
      target[key] = source[key];
    for (var j = 0; j < goog.object.PROTOTYPE_FIELDS_.length; j++) {
      key = goog.object.PROTOTYPE_FIELDS_[j];
      if (Object.prototype.hasOwnProperty.call(source, key))
        target[key] = source[key];
    }
  }
};
goog.object.create = function(var_args) {
  var argLength = arguments.length;
  if (argLength == 1 && goog.isArray(arguments[0]))
    return goog.object.create.apply(null, arguments[0]);
  if (argLength % 2) throw Error('Uneven number of arguments');
  var rv = {};
  for (var i = 0; i < argLength; i += 2)
    rv[arguments[i]] = arguments[i + 1];
  return rv;
};
goog.object.createSet = function(var_args) {
  var argLength = arguments.length;
  if (argLength == 1 && goog.isArray(arguments[0]))
    return goog.object.createSet.apply(null, arguments[0]);
  var rv = {};
  for (var i = 0; i < argLength; i++)
    rv[arguments[i]] = true;
  return rv;
};
goog.object.createImmutableView = function(obj) {
  var result = obj;
  if (Object.isFrozen && !Object.isFrozen(obj)) {
    result = Object.create(obj);
    Object.freeze(result);
  }
  return result;
};
goog.object.isImmutableView = function(obj) {
  return !!Object.isFrozen && Object.isFrozen(obj);
};
goog.provide('goog.math.Integer');
goog.math.Integer = function(bits, sign) {
  this.bits_ = [];
  this.sign_ = sign;
  var top = true;
  for (var i = bits.length - 1; i >= 0; i--) {
    var val = bits[i] | 0;
    if (!top || val != sign) {
      this.bits_[i] = val;
      top = false;
    }
  }
};
goog.math.Integer.IntCache_ = {};
goog.math.Integer.fromInt = function(value) {
  if (-128 <= value && value < 128) {
    var cachedObj = goog.math.Integer.IntCache_[value];
    if (cachedObj) return cachedObj;
  }
  var obj = new goog.math.Integer([value | 0], value < 0 ? -1 : 0);
  if (-128 <= value && value < 128) goog.math.Integer.IntCache_[value] = obj;
  return obj;
};
goog.math.Integer.fromNumber = function(value) {
  if (isNaN(value) || !isFinite(value))
    return goog.math.Integer.ZERO;
  else if (value < 0)
    return goog.math.Integer.fromNumber(-value).negate();
  else {
    var bits = [];
    var pow = 1;
    for (var i = 0; value >= pow; i++) {
      bits[i] = value / pow | 0;
      pow *= goog.math.Integer.TWO_PWR_32_DBL_;
    }
    return new goog.math.Integer(bits, 0);
  }
};
goog.math.Integer.fromBits = function(bits) {
  var high = bits[bits.length - 1];
  return new goog.math.Integer(bits, high & 1 << 31 ? -1 : 0);
};
goog.math.Integer.fromString = function(str, opt_radix) {
  if (str.length == 0) throw Error('number format error: empty string');
  var radix = opt_radix || 10;
  if (radix < 2 || 36 < radix) throw Error('radix out of range: ' + radix);
  if (str.charAt(0) == '-')
    return goog.math.Integer.fromString(str.substring(1), radix).negate();
  else if (str.indexOf('-') >= 0)
    throw Error('number format error: interior "-" character');
  var radixToPower = goog.math.Integer.fromNumber(Math.pow(radix, 8));
  var result = goog.math.Integer.ZERO;
  for (var i = 0; i < str.length; i += 8) {
    var size = Math.min(8, str.length - i);
    var value = parseInt(str.substring(i, i + size), radix);
    if (size < 8) {
      var power = goog.math.Integer.fromNumber(Math.pow(radix, size));
      result = result.multiply(power).add(goog.math.Integer.fromNumber(value));
    } else {
      result = result.multiply(radixToPower);
      result = result.add(goog.math.Integer.fromNumber(value));
    }
  }
  return result;
};
goog.math.Integer.TWO_PWR_32_DBL_ = (1 << 16) * (1 << 16);
goog.math.Integer.ZERO = goog.math.Integer.fromInt(0);
goog.math.Integer.ONE = goog.math.Integer.fromInt(1);
goog.math.Integer.TWO_PWR_24_ = goog.math.Integer.fromInt(1 << 24);
goog.math.Integer.prototype.toInt = function() {
  return this.bits_.length > 0 ? this.bits_[0] : this.sign_;
};
goog.math.Integer.prototype.toNumber = function() {
  if (this.isNegative())
    return -this.negate().toNumber();
  else {
    var val = 0;
    var pow = 1;
    for (var i = 0; i < this.bits_.length; i++) {
      val += this.getBitsUnsigned(i) * pow;
      pow *= goog.math.Integer.TWO_PWR_32_DBL_;
    }
    return val;
  }
};
goog.math.Integer.prototype.toString = function(opt_radix) {
  var radix = opt_radix || 10;
  if (radix < 2 || 36 < radix) throw Error('radix out of range: ' + radix);
  if (this.isZero()) return '0';
  else if (this.isNegative()) return '-' + this.negate().toString(radix);
  var radixToPower = goog.math.Integer.fromNumber(Math.pow(radix, 6));
  var rem = this;
  var result = '';
  while (true) {
    var remDiv = rem.divide(radixToPower);
    var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0;
    var digits = intval.toString(radix);
    rem = remDiv;
    if (rem.isZero())
      return digits + result;
    else {
      while (digits.length < 6)
        digits = '0' + digits;
      result = '' + digits + result;
    }
  }
};
goog.math.Integer.prototype.getBits = function(index) {
  if (index < 0) return 0;
  else if (index < this.bits_.length) return this.bits_[index];
  else return this.sign_;
};
goog.math.Integer.prototype.getBitsUnsigned = function(index) {
  var val = this.getBits(index);
  return val >= 0 ? val : goog.math.Integer.TWO_PWR_32_DBL_ + val;
};
goog.math.Integer.prototype.getSign = function() {
  return this.sign_;
};
goog.math.Integer.prototype.isZero = function() {
  if (this.sign_ != 0) return false;
  for (var i = 0; i < this.bits_.length; i++)
    if (this.bits_[i] != 0) return false;
  return true;
};
goog.math.Integer.prototype.isNegative = function() {
  return this.sign_ == -1;
};
goog.math.Integer.prototype.isOdd = function() {
  return (this.bits_.length == 0 && this.sign_ == -1) ||
    (this.bits_.length > 0 && (this.bits_[0] & 1) != 0);
};
goog.math.Integer.prototype.equals = function(other) {
  if (this.sign_ != other.sign_) return false;
  var len = Math.max(this.bits_.length, other.bits_.length);
  for (var i = 0; i < len; i++)
    if (this.getBits(i) != other.getBits(i)) return false;
  return true;
};
goog.math.Integer.prototype.notEquals = function(other) {
  return !this.equals(other);
};
goog.math.Integer.prototype.greaterThan = function(other) {
  return this.compare(other) > 0;
};
goog.math.Integer.prototype.greaterThanOrEqual = function(other) {
  return this.compare(other) >= 0;
};
goog.math.Integer.prototype.lessThan = function(other) {
  return this.compare(other) < 0;
};
goog.math.Integer.prototype.lessThanOrEqual = function(other) {
  return this.compare(other) <= 0;
};
goog.math.Integer.prototype.compare = function(other) {
  var diff = this.subtract(other);
  if (diff.isNegative()) return -1;
  else if (diff.isZero()) return 0;
  else return +1;
};
goog.math.Integer.prototype.shorten = function(numBits) {
  var arr_index = numBits - 1 >> 5;
  var bit_index = (numBits - 1) % 32;
  var bits = [];
  for (var i = 0; i < arr_index; i++)
    bits[i] = this.getBits(i);
  var sigBits = bit_index == 31 ? 4294967295 : (1 << bit_index + 1) - 1;
  var val = this.getBits(arr_index) & sigBits;
  if (val & 1 << bit_index) {
    val |= 4294967295 - sigBits;
    bits[arr_index] = val;
    return new goog.math.Integer(bits, -1);
  } else {
    bits[arr_index] = val;
    return new goog.math.Integer(bits, 0);
  }
};
goog.math.Integer.prototype.negate = function() {
  return this.not().add(goog.math.Integer.ONE);
};
goog.math.Integer.prototype.add = function(other) {
  var len = Math.max(this.bits_.length, other.bits_.length);
  var arr = [];
  var carry = 0;
  for (var i = 0; i <= len; i++) {
    var a1 = this.getBits(i) >>> 16;
    var a0 = this.getBits(i) & 65535;
    var b1 = other.getBits(i) >>> 16;
    var b0 = other.getBits(i) & 65535;
    var c0 = carry + a0 + b0;
    var c1 = (c0 >>> 16) + a1 + b1;
    carry = c1 >>> 16;
    c0 &= 65535;
    c1 &= 65535;
    arr[i] = c1 << 16 | c0;
  }
  return goog.math.Integer.fromBits(arr);
};
goog.math.Integer.prototype.subtract = function(other) {
  return this.add(other.negate());
};
goog.math.Integer.prototype.multiply = function(other) {
  if (this.isZero()) return goog.math.Integer.ZERO;
  else if (other.isZero()) return goog.math.Integer.ZERO;
  if (this.isNegative())
    if (other.isNegative()) return this.negate().multiply(other.negate());
    else return this.negate().multiply(other).negate();
  else if (other.isNegative()) return this.multiply(other.negate()).negate();
  if (
    this.lessThan(goog.math.Integer.TWO_PWR_24_) &&
    other.lessThan(goog.math.Integer.TWO_PWR_24_)
  )
    return goog.math.Integer.fromNumber(this.toNumber() * other.toNumber());
  var len = this.bits_.length + other.bits_.length;
  var arr = [];
  for (var i = 0; i < 2 * len; i++)
    arr[i] = 0;
  for (var i = 0; i < this.bits_.length; i++)
    for (var j = 0; j < other.bits_.length; j++) {
      var a1 = this.getBits(i) >>> 16;
      var a0 = this.getBits(i) & 65535;
      var b1 = other.getBits(j) >>> 16;
      var b0 = other.getBits(j) & 65535;
      arr[2 * i + 2 * j] += a0 * b0;
      goog.math.Integer.carry16_(arr, 2 * i + 2 * j);
      arr[2 * i + 2 * j + 1] += a1 * b0;
      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 1);
      arr[2 * i + 2 * j + 1] += a0 * b1;
      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 1);
      arr[2 * i + 2 * j + 2] += a1 * b1;
      goog.math.Integer.carry16_(arr, 2 * i + 2 * j + 2);
    }
  for (var i = 0; i < len; i++)
    arr[i] = arr[2 * i + 1] << 16 | arr[2 * i];
  for (var i = len; i < 2 * len; i++)
    arr[i] = 0;
  return new goog.math.Integer(arr, 0);
};
goog.math.Integer.carry16_ = function(bits, index) {
  while ((bits[index] & 65535) != bits[index]) {
    bits[index + 1] += bits[index] >>> 16;
    bits[index] &= 65535;
  }
};
goog.math.Integer.prototype.slowDivide_ = function(other) {
  if (this.isNegative() || other.isNegative())
    throw Error('slowDivide_ only works with positive integers.');
  var twoPower = goog.math.Integer.ONE;
  var multiple = other;
  while (multiple.lessThanOrEqual(this)) {
    twoPower = twoPower.shiftLeft(1);
    multiple = multiple.shiftLeft(1);
  }
  var res = twoPower.shiftRight(1);
  var total = multiple.shiftRight(1);
  var total2;
  multiple = multiple.shiftRight(2);
  twoPower = twoPower.shiftRight(2);
  while (!multiple.isZero()) {
    total2 = total.add(multiple);
    if (total2.lessThanOrEqual(this)) {
      res = res.add(twoPower);
      total = total2;
    }
    multiple = multiple.shiftRight(1);
    twoPower = twoPower.shiftRight(1);
  }
  return res;
};
goog.math.Integer.prototype.divide = function(other) {
  if (other.isZero()) throw Error('division by zero');
  else if (this.isZero()) return goog.math.Integer.ZERO;
  if (this.isNegative())
    if (other.isNegative()) return this.negate().divide(other.negate());
    else return this.negate().divide(other).negate();
  else if (other.isNegative()) return this.divide(other.negate()).negate();
  if (this.bits_.length > 30) return this.slowDivide_(other);
  var res = goog.math.Integer.ZERO;
  var rem = this;
  while (rem.greaterThanOrEqual(other)) {
    var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
    var log2 = Math.ceil(Math.log(approx) / Math.LN2);
    var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
    var approxRes = goog.math.Integer.fromNumber(approx);
    var approxRem = approxRes.multiply(other);
    while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
      approx -= delta;
      approxRes = goog.math.Integer.fromNumber(approx);
      approxRem = approxRes.multiply(other);
    }
    if (approxRes.isZero()) approxRes = goog.math.Integer.ONE;
    res = res.add(approxRes);
    rem = rem.subtract(approxRem);
  }
  return res;
};
goog.math.Integer.prototype.modulo = function(other) {
  return this.subtract(this.divide(other).multiply(other));
};
goog.math.Integer.prototype.not = function() {
  var len = this.bits_.length;
  var arr = [];
  for (var i = 0; i < len; i++)
    arr[i] = ~this.bits_[i];
  return new goog.math.Integer(arr, ~this.sign_);
};
goog.math.Integer.prototype.and = function(other) {
  var len = Math.max(this.bits_.length, other.bits_.length);
  var arr = [];
  for (var i = 0; i < len; i++)
    arr[i] = this.getBits(i) & other.getBits(i);
  return new goog.math.Integer(arr, this.sign_ & other.sign_);
};
goog.math.Integer.prototype.or = function(other) {
  var len = Math.max(this.bits_.length, other.bits_.length);
  var arr = [];
  for (var i = 0; i < len; i++)
    arr[i] = this.getBits(i) | other.getBits(i);
  return new goog.math.Integer(arr, this.sign_ | other.sign_);
};
goog.math.Integer.prototype.xor = function(other) {
  var len = Math.max(this.bits_.length, other.bits_.length);
  var arr = [];
  for (var i = 0; i < len; i++)
    arr[i] = this.getBits(i) ^ other.getBits(i);
  return new goog.math.Integer(arr, this.sign_ ^ other.sign_);
};
goog.math.Integer.prototype.shiftLeft = function(numBits) {
  var arr_delta = numBits >> 5;
  var bit_delta = numBits % 32;
  var len = this.bits_.length + arr_delta + (bit_delta > 0 ? 1 : 0);
  var arr = [];
  for (var i = 0; i < len; i++)
    if (bit_delta > 0)
      arr[i] = this.getBits(i - arr_delta) << bit_delta |
        this.getBits(i - arr_delta - 1) >>> 32 - bit_delta;
    else
      arr[i] = this.getBits(i - arr_delta);
  return new goog.math.Integer(arr, this.sign_);
};
goog.math.Integer.prototype.shiftRight = function(numBits) {
  var arr_delta = numBits >> 5;
  var bit_delta = numBits % 32;
  var len = this.bits_.length - arr_delta;
  var arr = [];
  for (var i = 0; i < len; i++)
    if (bit_delta > 0)
      arr[i] = this.getBits(i + arr_delta) >>> bit_delta |
        this.getBits(i + arr_delta + 1) << 32 - bit_delta;
    else
      arr[i] = this.getBits(i + arr_delta);
  return new goog.math.Integer(arr, this.sign_);
};
goog.provide('goog.string.StringBuffer');
goog.string.StringBuffer = function(opt_a1, var_args) {
  if (opt_a1 != null) this.append.apply(this, arguments);
};
goog.string.StringBuffer.prototype.buffer_ = '';
goog.string.StringBuffer.prototype.set = function(s) {
  this.buffer_ = '' + s;
};
goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
  this.buffer_ += String(a1);
  if (opt_a2 != null)
    for (var i = 1; i < arguments.length; i++)
      this.buffer_ += arguments[i];
  return this;
};
goog.string.StringBuffer.prototype.clear = function() {
  this.buffer_ = '';
};
goog.string.StringBuffer.prototype.getLength = function() {
  return this.buffer_.length;
};
goog.string.StringBuffer.prototype.toString = function() {
  return this.buffer_;
};
goog.provide('goog.debug.Error');
goog.debug.Error = function(opt_msg) {
  if (Error.captureStackTrace)
    Error.captureStackTrace(this, goog.debug.Error);
  else {
    var stack = new Error().stack;
    if (stack) this.stack = stack;
  }
  if (opt_msg) this.message = String(opt_msg);
  this.reportErrorToServer = true;
};
goog.inherits(goog.debug.Error, Error);
goog.debug.Error.prototype.name = 'CustomError';
goog.provide('goog.dom.NodeType');
goog.dom.NodeType = {
  ELEMENT: 1,
  ATTRIBUTE: 2,
  TEXT: 3,
  CDATA_SECTION: 4,
  ENTITY_REFERENCE: 5,
  ENTITY: 6,
  PROCESSING_INSTRUCTION: 7,
  COMMENT: 8,
  DOCUMENT: 9,
  DOCUMENT_TYPE: 10,
  DOCUMENT_FRAGMENT: 11,
  NOTATION: 12
};
goog.provide('goog.asserts');
goog.provide('goog.asserts.AssertionError');
goog.require('goog.debug.Error');
goog.require('goog.dom.NodeType');
goog.require('goog.string');
goog.define('goog.asserts.ENABLE_ASSERTS', goog.DEBUG);
goog.asserts.AssertionError = function(messagePattern, messageArgs) {
  messageArgs.unshift(messagePattern);
  goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
  messageArgs.shift();
  this.messagePattern = messagePattern;
};
goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
goog.asserts.AssertionError.prototype.name = 'AssertionError';
goog.asserts.DEFAULT_ERROR_HANDLER = function(e) {
  throw e;
};
goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
goog.asserts.doAssertFailure_ = function(
  defaultMessage,
  defaultArgs,
  givenMessage,
  givenArgs
) {
  var message = 'Assertion failed';
  if (givenMessage) {
    message += ': ' + givenMessage;
    var args = givenArgs;
  } else if (defaultMessage) {
    message += ': ' + defaultMessage;
    args = defaultArgs;
  }
  var e = new goog.asserts.AssertionError('' + message, args || []);
  goog.asserts.errorHandler_(e);
};
goog.asserts.setErrorHandler = function(errorHandler) {
  if (goog.asserts.ENABLE_ASSERTS) goog.asserts.errorHandler_ = errorHandler;
};
goog.asserts.assert = function(condition, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !condition)
    goog.asserts.doAssertFailure_(
      '',
      null,
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return condition;
};
goog.asserts.fail = function(opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS)
    goog.asserts.errorHandler_(
      new goog.asserts.AssertionError(
        'Failure' + (opt_message ? ': ' + opt_message : ''),
        Array.prototype.slice.call(arguments, 1)
      )
    );
};
goog.asserts.assertNumber = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isNumber(value))
    goog.asserts.doAssertFailure_(
      'Expected number but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertString = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isString(value))
    goog.asserts.doAssertFailure_(
      'Expected string but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertFunction = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isFunction(value))
    goog.asserts.doAssertFailure_(
      'Expected function but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertObject = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isObject(value))
    goog.asserts.doAssertFailure_(
      'Expected object but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertArray = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isArray(value))
    goog.asserts.doAssertFailure_(
      'Expected array but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertBoolean = function(value, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !goog.isBoolean(value))
    goog.asserts.doAssertFailure_(
      'Expected boolean but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertElement = function(value, opt_message, var_args) {
  if (
    goog.asserts.ENABLE_ASSERTS &&
    (!goog.isObject(value) || value.nodeType != goog.dom.NodeType.ELEMENT)
  )
    goog.asserts.doAssertFailure_(
      'Expected Element but got %s: %s.',
      [goog.typeOf(value), value],
      opt_message,
      Array.prototype.slice.call(arguments, 2)
    );
  return value;
};
goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
  if (goog.asserts.ENABLE_ASSERTS && !(value instanceof type))
    goog.asserts.doAssertFailure_(
      'Expected instanceof %s but got %s.',
      [goog.asserts.getType_(type), goog.asserts.getType_(value)],
      opt_message,
      Array.prototype.slice.call(arguments, 3)
    );
  return value;
};
goog.asserts.assertObjectPrototypeIsIntact = function() {
  for (var key in Object.prototype)
    goog.asserts.fail(key + ' should not be enumerable in Object.prototype.');
};
goog.asserts.getType_ = function(value) {
  if (value instanceof Function)
    return value.displayName || value.name || 'unknown type name';
  else if (value instanceof Object)
    return value.constructor.displayName ||
      value.constructor.name ||
      Object.prototype.toString.call(value);
  else
    return value === null ? 'null' : typeof value;
};
goog.provide('goog.array');
goog.require('goog.asserts');
goog.define('goog.NATIVE_ARRAY_PROTOTYPES', goog.TRUSTED_SITE);
goog.define('goog.array.ASSUME_NATIVE_FUNCTIONS', false);
goog.array.peek = function(array) {
  return array[array.length - 1];
};
goog.array.last = goog.array.peek;
goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.indexOf)
  ? function(arr, obj, opt_fromIndex) {
      goog.asserts.assert(arr.length != null);
      return Array.prototype.indexOf.call(arr, obj, opt_fromIndex);
    }
  : function(arr, obj, opt_fromIndex) {
      var fromIndex = opt_fromIndex == null
        ? 0
        : opt_fromIndex < 0
            ? Math.max(0, arr.length + opt_fromIndex)
            : opt_fromIndex;
      if (goog.isString(arr)) {
        if (!goog.isString(obj) || obj.length != 1) return -1;
        return arr.indexOf(obj, fromIndex);
      }
      for (var i = fromIndex; i < arr.length; i++)
        if (i in arr && arr[i] === obj) return i;
      return -1;
    };
goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.lastIndexOf)
  ? function(arr, obj, opt_fromIndex) {
      goog.asserts.assert(arr.length != null);
      var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
      return Array.prototype.lastIndexOf.call(arr, obj, fromIndex);
    }
  : function(arr, obj, opt_fromIndex) {
      var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
      if (fromIndex < 0) fromIndex = Math.max(0, arr.length + fromIndex);
      if (goog.isString(arr)) {
        if (!goog.isString(obj) || obj.length != 1) return -1;
        return arr.lastIndexOf(obj, fromIndex);
      }
      for (var i = fromIndex; i >= 0; i--)
        if (i in arr && arr[i] === obj) return i;
      return -1;
    };
goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.forEach)
  ? function(arr, f, opt_obj) {
      goog.asserts.assert(arr.length != null);
      Array.prototype.forEach.call(arr, f, opt_obj);
    }
  : function(arr, f, opt_obj) {
      var l = arr.length;
      var arr2 = goog.isString(arr) ? arr.split('') : arr;
      for (var i = 0; i < l; i++)
        if (i in arr2) f.call(opt_obj, arr2[i], i, arr);
    };
goog.array.forEachRight = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split('') : arr;
  for (var i = l - 1; i >= 0; --i)
    if (i in arr2) f.call(opt_obj, arr2[i], i, arr);
};
goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.filter)
  ? function(arr, f, opt_obj) {
      goog.asserts.assert(arr.length != null);
      return Array.prototype.filter.call(arr, f, opt_obj);
    }
  : function(arr, f, opt_obj) {
      var l = arr.length;
      var res = [];
      var resLength = 0;
      var arr2 = goog.isString(arr) ? arr.split('') : arr;
      for (var i = 0; i < l; i++)
        if (i in arr2) {
          var val = arr2[i];
          if (f.call(opt_obj, val, i, arr)) res[resLength++] = val;
        }
      return res;
    };
goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.map)
  ? function(arr, f, opt_obj) {
      goog.asserts.assert(arr.length != null);
      return Array.prototype.map.call(arr, f, opt_obj);
    }
  : function(arr, f, opt_obj) {
      var l = arr.length;
      var res = new Array(l);
      var arr2 = goog.isString(arr) ? arr.split('') : arr;
      for (var i = 0; i < l; i++)
        if (i in arr2) res[i] = f.call(opt_obj, arr2[i], i, arr);
      return res;
    };
goog.array.reduce = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduce)
  ? function(arr, f, val, opt_obj) {
      goog.asserts.assert(arr.length != null);
      if (opt_obj) f = goog.bind(f, opt_obj);
      return Array.prototype.reduce.call(arr, f, val);
    }
  : function(arr, f, val, opt_obj) {
      var rval = val;
      goog.array.forEach(arr, function(val, index) {
        rval = f.call(opt_obj, rval, val, index, arr);
      });
      return rval;
    };
goog.array.reduceRight = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduceRight)
  ? function(arr, f, val, opt_obj) {
      goog.asserts.assert(arr.length != null);
      goog.asserts.assert(f != null);
      if (opt_obj) f = goog.bind(f, opt_obj);
      return Array.prototype.reduceRight.call(arr, f, val);
    }
  : function(arr, f, val, opt_obj) {
      var rval = val;
      goog.array.forEachRight(arr, function(val, index) {
        rval = f.call(opt_obj, rval, val, index, arr);
      });
      return rval;
    };
goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.some)
  ? function(arr, f, opt_obj) {
      goog.asserts.assert(arr.length != null);
      return Array.prototype.some.call(arr, f, opt_obj);
    }
  : function(arr, f, opt_obj) {
      var l = arr.length;
      var arr2 = goog.isString(arr) ? arr.split('') : arr;
      for (var i = 0; i < l; i++)
        if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) return true;
      return false;
    };
goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES &&
  (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.every)
  ? function(arr, f, opt_obj) {
      goog.asserts.assert(arr.length != null);
      return Array.prototype.every.call(arr, f, opt_obj);
    }
  : function(arr, f, opt_obj) {
      var l = arr.length;
      var arr2 = goog.isString(arr) ? arr.split('') : arr;
      for (var i = 0; i < l; i++)
        if (i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) return false;
      return true;
    };
goog.array.count = function(arr, f, opt_obj) {
  var count = 0;
  goog.array.forEach(
    arr,
    function(element, index, arr) {
      if (f.call(opt_obj, element, index, arr)) ++count;
    },
    opt_obj
  );
  return count;
};
goog.array.find = function(arr, f, opt_obj) {
  var i = goog.array.findIndex(arr, f, opt_obj);
  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndex = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split('') : arr;
  for (var i = 0; i < l; i++)
    if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) return i;
  return -1;
};
goog.array.findRight = function(arr, f, opt_obj) {
  var i = goog.array.findIndexRight(arr, f, opt_obj);
  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndexRight = function(arr, f, opt_obj) {
  var l = arr.length;
  var arr2 = goog.isString(arr) ? arr.split('') : arr;
  for (var i = l - 1; i >= 0; i--)
    if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) return i;
  return -1;
};
goog.array.contains = function(arr, obj) {
  return goog.array.indexOf(arr, obj) >= 0;
};
goog.array.isEmpty = function(arr) {
  return arr.length == 0;
};
goog.array.clear = function(arr) {
  if (!goog.isArray(arr))
    for (var i = arr.length - 1; i >= 0; i--)
      delete arr[i];
  arr.length = 0;
};
goog.array.insert = function(arr, obj) {
  if (!goog.array.contains(arr, obj)) arr.push(obj);
};
goog.array.insertAt = function(arr, obj, opt_i) {
  goog.array.splice(arr, opt_i, 0, obj);
};
goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
  goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd);
};
goog.array.insertBefore = function(arr, obj, opt_obj2) {
  var i;
  if (arguments.length == 2 || (i = goog.array.indexOf(arr, opt_obj2)) < 0)
    arr.push(obj);
  else
    goog.array.insertAt(arr, obj, i);
};
goog.array.remove = function(arr, obj) {
  var i = goog.array.indexOf(arr, obj);
  var rv;
  if ((rv = i >= 0)) goog.array.removeAt(arr, i);
  return rv;
};
goog.array.removeLast = function(arr, obj) {
  var i = goog.array.lastIndexOf(arr, obj);
  if (i >= 0) {
    goog.array.removeAt(arr, i);
    return true;
  }
  return false;
};
goog.array.removeAt = function(arr, i) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.splice.call(arr, i, 1).length == 1;
};
goog.array.removeIf = function(arr, f, opt_obj) {
  var i = goog.array.findIndex(arr, f, opt_obj);
  if (i >= 0) {
    goog.array.removeAt(arr, i);
    return true;
  }
  return false;
};
goog.array.removeAllIf = function(arr, f, opt_obj) {
  var removedCount = 0;
  goog.array.forEachRight(arr, function(val, index) {
    if (f.call(opt_obj, val, index, arr))
      if (goog.array.removeAt(arr, index)) removedCount++;
  });
  return removedCount;
};
goog.array.concat = function(var_args) {
  return Array.prototype.concat.apply(Array.prototype, arguments);
};
goog.array.join = function(var_args) {
  return Array.prototype.concat.apply(Array.prototype, arguments);
};
goog.array.toArray = function(object) {
  var length = object.length;
  if (length > 0) {
    var rv = new Array(length);
    for (var i = 0; i < length; i++)
      rv[i] = object[i];
    return rv;
  }
  return [];
};
goog.array.clone = goog.array.toArray;
goog.array.extend = function(arr1, var_args) {
  for (var i = 1; i < arguments.length; i++) {
    var arr2 = arguments[i];
    if (goog.isArrayLike(arr2)) {
      var len1 = arr1.length || 0;
      var len2 = arr2.length || 0;
      arr1.length = len1 + len2;
      for (var j = 0; j < len2; j++)
        arr1[len1 + j] = arr2[j];
    } else
      arr1.push(arr2);
  }
};
goog.array.splice = function(arr, index, howMany, var_args) {
  goog.asserts.assert(arr.length != null);
  return Array.prototype.splice.apply(arr, goog.array.slice(arguments, 1));
};
goog.array.slice = function(arr, start, opt_end) {
  goog.asserts.assert(arr.length != null);
  if (arguments.length <= 2) return Array.prototype.slice.call(arr, start);
  else return Array.prototype.slice.call(arr, start, opt_end);
};
goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
  var returnArray = opt_rv || arr;
  var defaultHashFn = function(item) {
    return goog.isObject(item)
      ? 'o' + goog.getUid(item)
      : (typeof item).charAt(0) + item;
  };
  var hashFn = opt_hashFn || defaultHashFn;
  var seen = {}, cursorInsert = 0, cursorRead = 0;
  while (cursorRead < arr.length) {
    var current = arr[cursorRead++];
    var key = hashFn(current);
    if (!Object.prototype.hasOwnProperty.call(seen, key)) {
      seen[key] = true;
      returnArray[cursorInsert++] = current;
    }
  }
  returnArray.length = cursorInsert;
};
goog.array.binarySearch = function(arr, target, opt_compareFn) {
  return goog.array.binarySearch_(
    arr,
    opt_compareFn || goog.array.defaultCompare,
    false,
    target
  );
};
goog.array.binarySelect = function(arr, evaluator, opt_obj) {
  return goog.array.binarySearch_(arr, evaluator, true, undefined, opt_obj);
};
goog.array.binarySearch_ = function(
  arr,
  compareFn,
  isEvaluator,
  opt_target,
  opt_selfObj
) {
  var left = 0;
  var right = arr.length;
  var found;
  while (left < right) {
    var middle = left + right >> 1;
    var compareResult;
    if (isEvaluator)
      compareResult = compareFn.call(opt_selfObj, arr[middle], middle, arr);
    else
      compareResult = compareFn(opt_target, arr[middle]);
    if (compareResult > 0)
      left = middle + 1;
    else {
      right = middle;
      found = !compareResult;
    }
  }
  return found ? left : ~left;
};
goog.array.sort = function(arr, opt_compareFn) {
  arr.sort(opt_compareFn || goog.array.defaultCompare);
};
goog.array.stableSort = function(arr, opt_compareFn) {
  var compArr = new Array(arr.length);
  for (var i = 0; i < arr.length; i++)
    compArr[i] = { index: i, value: arr[i] };
  var valueCompareFn = opt_compareFn || goog.array.defaultCompare;
  function stableCompareFn(obj1, obj2) {
    return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;
  }
  goog.array.sort(compArr, stableCompareFn);
  for (var i = 0; i < arr.length; i++)
    arr[i] = compArr[i].value;
};
goog.array.sortByKey = function(arr, keyFn, opt_compareFn) {
  var keyCompareFn = opt_compareFn || goog.array.defaultCompare;
  goog.array.sort(arr, function(a, b) {
    return keyCompareFn(keyFn(a), keyFn(b));
  });
};
goog.array.sortObjectsByKey = function(arr, key, opt_compareFn) {
  goog.array.sortByKey(
    arr,
    function(obj) {
      return obj[key];
    },
    opt_compareFn
  );
};
goog.array.isSorted = function(arr, opt_compareFn, opt_strict) {
  var compare = opt_compareFn || goog.array.defaultCompare;
  for (var i = 1; i < arr.length; i++) {
    var compareResult = compare(arr[i - 1], arr[i]);
    if (compareResult > 0 || (compareResult == 0 && opt_strict)) return false;
  }
  return true;
};
goog.array.equals = function(arr1, arr2, opt_equalsFn) {
  if (
    !goog.isArrayLike(arr1) ||
    !goog.isArrayLike(arr2) ||
    arr1.length != arr2.length
  )
    return false;
  var l = arr1.length;
  var equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
  for (var i = 0; i < l; i++)
    if (!equalsFn(arr1[i], arr2[i])) return false;
  return true;
};
goog.array.compare3 = function(arr1, arr2, opt_compareFn) {
  var compare = opt_compareFn || goog.array.defaultCompare;
  var l = Math.min(arr1.length, arr2.length);
  for (var i = 0; i < l; i++) {
    var result = compare(arr1[i], arr2[i]);
    if (result != 0) return result;
  }
  return goog.array.defaultCompare(arr1.length, arr2.length);
};
goog.array.defaultCompare = function(a, b) {
  return a > b ? 1 : a < b ? -1 : 0;
};
goog.array.inverseDefaultCompare = function(a, b) {
  return -goog.array.defaultCompare(a, b);
};
goog.array.defaultCompareEquality = function(a, b) {
  return a === b;
};
goog.array.binaryInsert = function(array, value, opt_compareFn) {
  var index = goog.array.binarySearch(array, value, opt_compareFn);
  if (index < 0) {
    goog.array.insertAt(array, value, -(index + 1));
    return true;
  }
  return false;
};
goog.array.binaryRemove = function(array, value, opt_compareFn) {
  var index = goog.array.binarySearch(array, value, opt_compareFn);
  return index >= 0 ? goog.array.removeAt(array, index) : false;
};
goog.array.bucket = function(array, sorter, opt_obj) {
  var buckets = {};
  for (var i = 0; i < array.length; i++) {
    var value = array[i];
    var key = sorter.call(opt_obj, value, i, array);
    if (goog.isDef(key)) {
      var bucket = buckets[key] || (buckets[key] = []);
      bucket.push(value);
    }
  }
  return buckets;
};
goog.array.toObject = function(arr, keyFunc, opt_obj) {
  var ret = {};
  goog.array.forEach(arr, function(element, index) {
    ret[keyFunc.call(opt_obj, element, index, arr)] = element;
  });
  return ret;
};
goog.array.range = function(startOrEnd, opt_end, opt_step) {
  var array = [];
  var start = 0;
  var end = startOrEnd;
  var step = opt_step || 1;
  if (opt_end !== undefined) {
    start = startOrEnd;
    end = opt_end;
  }
  if (step * (end - start) < 0) return [];
  if (step > 0) for (var i = start; i < end; i += step) array.push(i);
  else for (var i = start; i > end; i += step) array.push(i);
  return array;
};
goog.array.repeat = function(value, n) {
  var array = [];
  for (var i = 0; i < n; i++)
    array[i] = value;
  return array;
};
goog.array.flatten = function(var_args) {
  var CHUNK_SIZE = 8192;
  var result = [];
  for (var i = 0; i < arguments.length; i++) {
    var element = arguments[i];
    if (goog.isArray(element))
      for (var c = 0; c < element.length; c += CHUNK_SIZE) {
        var chunk = goog.array.slice(element, c, c + CHUNK_SIZE);
        var recurseResult = goog.array.flatten.apply(null, chunk);
        for (var r = 0; r < recurseResult.length; r++)
          result.push(recurseResult[r]);
      }
    else
      result.push(element);
  }
  return result;
};
goog.array.rotate = function(array, n) {
  goog.asserts.assert(array.length != null);
  if (array.length) {
    n %= array.length;
    if (n > 0) Array.prototype.unshift.apply(array, array.splice(-n, n));
    else if (n < 0) Array.prototype.push.apply(array, array.splice(0, -n));
  }
  return array;
};
goog.array.moveItem = function(arr, fromIndex, toIndex) {
  goog.asserts.assert(fromIndex >= 0 && fromIndex < arr.length);
  goog.asserts.assert(toIndex >= 0 && toIndex < arr.length);
  var removedItems = Array.prototype.splice.call(arr, fromIndex, 1);
  Array.prototype.splice.call(arr, toIndex, 0, removedItems[0]);
};
goog.array.zip = function(var_args) {
  if (!arguments.length) return [];
  var result = [];
  var minLen = arguments[0].length;
  for (var i = 1; i < arguments.length; i++)
    if (arguments[i].length < minLen) minLen = arguments[i].length;
  for (var i = 0; i < minLen; i++) {
    var value = [];
    for (var j = 0; j < arguments.length; j++)
      value.push(arguments[j][i]);
    result.push(value);
  }
  return result;
};
goog.array.shuffle = function(arr, opt_randFn) {
  var randFn = opt_randFn || Math.random;
  for (var i = arr.length - 1; i > 0; i--) {
    var j = Math.floor(randFn() * (i + 1));
    var tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
  }
};
goog.array.copyByIndex = function(arr, index_arr) {
  var result = [];
  goog.array.forEach(index_arr, function(index) {
    result.push(arr[index]);
  });
  return result;
};
goog.array.concatMap = function(arr, f, opt_obj) {
  return goog.array.concat.apply([], goog.array.map(arr, f, opt_obj));
};
goog.provide('goog.reflect');
goog.reflect.object = function(type, object) {
  return object;
};
goog.reflect.objectProperty = function(prop, object) {
  return prop;
};
goog.reflect.sinkValue = function(x) {
  goog.reflect.sinkValue[' '](x);
  return x;
};
goog.reflect.sinkValue[' '] = goog.nullFunction;
goog.reflect.canAccessProperty = function(obj, prop) {
  try {
    goog.reflect.sinkValue(obj[prop]);
    return true;
  } catch (e) {}
  return false;
};
goog.reflect.cache = function(cacheObj, key, valueFn, opt_keyFn) {
  var storedKey = opt_keyFn ? opt_keyFn(key) : key;
  if (Object.prototype.hasOwnProperty.call(cacheObj, storedKey))
    return cacheObj[storedKey];
  return (cacheObj[storedKey] = valueFn(key));
};
goog.provide('goog.math.Long');
goog.require('goog.reflect');
goog.math.Long = function(low, high) {
  this.low_ = low | 0;
  this.high_ = high | 0;
};
goog.math.Long.IntCache_ = {};
goog.math.Long.valueCache_ = {};
goog.math.Long.fromInt = function(value) {
  if (-128 <= value && value < 128)
    return goog.reflect.cache(goog.math.Long.IntCache_, value, function(val) {
      return new goog.math.Long(val | 0, val < 0 ? -1 : 0);
    });
  else
    return new goog.math.Long(value | 0, value < 0 ? -1 : 0);
};
goog.math.Long.fromNumber = function(value) {
  if (isNaN(value)) return goog.math.Long.getZero();
  else if (value <= -goog.math.Long.TWO_PWR_63_DBL_)
    return goog.math.Long.getMinValue();
  else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_)
    return goog.math.Long.getMaxValue();
  else if (value < 0) return goog.math.Long.fromNumber(-value).negate();
  else return new goog.math.Long(
      value % goog.math.Long.TWO_PWR_32_DBL_ | 0,
      value / goog.math.Long.TWO_PWR_32_DBL_ | 0
    );
};
goog.math.Long.fromBits = function(lowBits, highBits) {
  return new goog.math.Long(lowBits, highBits);
};
goog.math.Long.fromString = function(str, opt_radix) {
  if (str.length == 0) throw Error('number format error: empty string');
  var radix = opt_radix || 10;
  if (radix < 2 || 36 < radix) throw Error('radix out of range: ' + radix);
  if (str.charAt(0) == '-')
    return goog.math.Long.fromString(str.substring(1), radix).negate();
  else if (str.indexOf('-') >= 0)
    throw Error('number format error: interior "-" character: ' + str);
  var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));
  var result = goog.math.Long.getZero();
  for (var i = 0; i < str.length; i += 8) {
    var size = Math.min(8, str.length - i);
    var value = parseInt(str.substring(i, i + size), radix);
    if (size < 8) {
      var power = goog.math.Long.fromNumber(Math.pow(radix, size));
      result = result.multiply(power).add(goog.math.Long.fromNumber(value));
    } else {
      result = result.multiply(radixToPower);
      result = result.add(goog.math.Long.fromNumber(value));
    }
  }
  return result;
};
goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;
goog.math.Long.TWO_PWR_32_DBL_ = goog.math.Long.TWO_PWR_16_DBL_ *
  goog.math.Long.TWO_PWR_16_DBL_;
goog.math.Long.TWO_PWR_64_DBL_ = goog.math.Long.TWO_PWR_32_DBL_ *
  goog.math.Long.TWO_PWR_32_DBL_;
goog.math.Long.TWO_PWR_63_DBL_ = goog.math.Long.TWO_PWR_64_DBL_ / 2;
goog.math.Long.getZero = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.ZERO,
    function() {
      return goog.math.Long.fromInt(0);
    }
  );
};
goog.math.Long.getOne = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.ONE,
    function() {
      return goog.math.Long.fromInt(1);
    }
  );
};
goog.math.Long.getNegOne = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.NEG_ONE,
    function() {
      return goog.math.Long.fromInt(-1);
    }
  );
};
goog.math.Long.getMaxValue = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.MAX_VALUE,
    function() {
      return goog.math.Long.fromBits(4294967295 | 0, 2147483647 | 0);
    }
  );
};
goog.math.Long.getMinValue = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.MIN_VALUE,
    function() {
      return goog.math.Long.fromBits(0, 2147483648 | 0);
    }
  );
};
goog.math.Long.getTwoPwr24 = function() {
  return goog.reflect.cache(
    goog.math.Long.valueCache_,
    goog.math.Long.ValueCacheId_.TWO_PWR_24,
    function() {
      return goog.math.Long.fromInt(1 << 24);
    }
  );
};
goog.math.Long.prototype.toInt = function() {
  return this.low_;
};
goog.math.Long.prototype.toNumber = function() {
  return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +
    this.getLowBitsUnsigned();
};
goog.math.Long.prototype.toString = function(opt_radix) {
  var radix = opt_radix || 10;
  if (radix < 2 || 36 < radix) throw Error('radix out of range: ' + radix);
  if (this.isZero()) return '0';
  if (this.isNegative())
    if (this.equals(goog.math.Long.getMinValue())) {
      var radixLong = goog.math.Long.fromNumber(radix);
      var div = this.div(radixLong);
      var rem = div.multiply(radixLong).subtract(this);
      return div.toString(radix) + rem.toInt().toString(radix);
    } else
      return '-' + this.negate().toString(radix);
  var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));
  var rem = this;
  var result = '';
  while (true) {
    var remDiv = rem.div(radixToPower);
    var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt() >>> 0;
    var digits = intval.toString(radix);
    rem = remDiv;
    if (rem.isZero())
      return digits + result;
    else {
      while (digits.length < 6)
        digits = '0' + digits;
      result = '' + digits + result;
    }
  }
};
goog.math.Long.prototype.getHighBits = function() {
  return this.high_;
};
goog.math.Long.prototype.getLowBits = function() {
  return this.low_;
};
goog.math.Long.prototype.getLowBitsUnsigned = function() {
  return this.low_ >= 0
    ? this.low_
    : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;
};
goog.math.Long.prototype.getNumBitsAbs = function() {
  if (this.isNegative())
    if (this.equals(goog.math.Long.getMinValue())) return 64;
    else return this.negate().getNumBitsAbs();
  else {
    var val = this.high_ != 0 ? this.high_ : this.low_;
    for (var bit = 31; bit > 0; bit--)
      if ((val & 1 << bit) != 0) break;
    return this.high_ != 0 ? bit + 33 : bit + 1;
  }
};
goog.math.Long.prototype.isZero = function() {
  return this.high_ == 0 && this.low_ == 0;
};
goog.math.Long.prototype.isNegative = function() {
  return this.high_ < 0;
};
goog.math.Long.prototype.isOdd = function() {
  return (this.low_ & 1) == 1;
};
goog.math.Long.prototype.equals = function(other) {
  return this.high_ == other.high_ && this.low_ == other.low_;
};
goog.math.Long.prototype.notEquals = function(other) {
  return this.high_ != other.high_ || this.low_ != other.low_;
};
goog.math.Long.prototype.lessThan = function(other) {
  return this.compare(other) < 0;
};
goog.math.Long.prototype.lessThanOrEqual = function(other) {
  return this.compare(other) <= 0;
};
goog.math.Long.prototype.greaterThan = function(other) {
  return this.compare(other) > 0;
};
goog.math.Long.prototype.greaterThanOrEqual = function(other) {
  return this.compare(other) >= 0;
};
goog.math.Long.prototype.compare = function(other) {
  if (this.equals(other)) return 0;
  var thisNeg = this.isNegative();
  var otherNeg = other.isNegative();
  if (thisNeg && !otherNeg) return -1;
  if (!thisNeg && otherNeg) return 1;
  if (this.subtract(other).isNegative()) return -1;
  else return 1;
};
goog.math.Long.prototype.negate = function() {
  if (this.equals(goog.math.Long.getMinValue()))
    return goog.math.Long.getMinValue();
  else
    return this.not().add(goog.math.Long.getOne());
};
goog.math.Long.prototype.add = function(other) {
  var a48 = this.high_ >>> 16;
  var a32 = this.high_ & 65535;
  var a16 = this.low_ >>> 16;
  var a00 = this.low_ & 65535;
  var b48 = other.high_ >>> 16;
  var b32 = other.high_ & 65535;
  var b16 = other.low_ >>> 16;
  var b00 = other.low_ & 65535;
  var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
  c00 += a00 + b00;
  c16 += c00 >>> 16;
  c00 &= 65535;
  c16 += a16 + b16;
  c32 += c16 >>> 16;
  c16 &= 65535;
  c32 += a32 + b32;
  c48 += c32 >>> 16;
  c32 &= 65535;
  c48 += a48 + b48;
  c48 &= 65535;
  return goog.math.Long.fromBits(c16 << 16 | c00, c48 << 16 | c32);
};
goog.math.Long.prototype.subtract = function(other) {
  return this.add(other.negate());
};
goog.math.Long.prototype.multiply = function(other) {
  if (this.isZero()) return goog.math.Long.getZero();
  else if (other.isZero()) return goog.math.Long.getZero();
  if (this.equals(goog.math.Long.getMinValue()))
    return other.isOdd()
      ? goog.math.Long.getMinValue()
      : goog.math.Long.getZero();
  else if (other.equals(goog.math.Long.getMinValue()))
    return this.isOdd()
      ? goog.math.Long.getMinValue()
      : goog.math.Long.getZero();
  if (this.isNegative())
    if (other.isNegative()) return this.negate().multiply(other.negate());
    else return this.negate().multiply(other).negate();
  else if (other.isNegative()) return this.multiply(other.negate()).negate();
  if (
    this.lessThan(goog.math.Long.getTwoPwr24()) &&
    other.lessThan(goog.math.Long.getTwoPwr24())
  )
    return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());
  var a48 = this.high_ >>> 16;
  var a32 = this.high_ & 65535;
  var a16 = this.low_ >>> 16;
  var a00 = this.low_ & 65535;
  var b48 = other.high_ >>> 16;
  var b32 = other.high_ & 65535;
  var b16 = other.low_ >>> 16;
  var b00 = other.low_ & 65535;
  var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
  c00 += a00 * b00;
  c16 += c00 >>> 16;
  c00 &= 65535;
  c16 += a16 * b00;
  c32 += c16 >>> 16;
  c16 &= 65535;
  c16 += a00 * b16;
  c32 += c16 >>> 16;
  c16 &= 65535;
  c32 += a32 * b00;
  c48 += c32 >>> 16;
  c32 &= 65535;
  c32 += a16 * b16;
  c48 += c32 >>> 16;
  c32 &= 65535;
  c32 += a00 * b32;
  c48 += c32 >>> 16;
  c32 &= 65535;
  c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
  c48 &= 65535;
  return goog.math.Long.fromBits(c16 << 16 | c00, c48 << 16 | c32);
};
goog.math.Long.prototype.div = function(other) {
  if (other.isZero()) throw Error('division by zero');
  else if (this.isZero()) return goog.math.Long.getZero();
  if (this.equals(goog.math.Long.getMinValue()))
    if (
      other.equals(goog.math.Long.getOne()) ||
      other.equals(goog.math.Long.getNegOne())
    )
      return goog.math.Long.getMinValue();
    else if (other.equals(goog.math.Long.getMinValue()))
      return goog.math.Long.getOne();
    else {
      var halfThis = this.shiftRight(1);
      var approx = halfThis.div(other).shiftLeft(1);
      if (approx.equals(goog.math.Long.getZero()))
        return other.isNegative()
          ? goog.math.Long.getOne()
          : goog.math.Long.getNegOne();
      else {
        var rem = this.subtract(other.multiply(approx));
        var result = approx.add(rem.div(other));
        return result;
      }
    }
  else if (other.equals(goog.math.Long.getMinValue()))
    return goog.math.Long.getZero();
  if (this.isNegative())
    if (other.isNegative()) return this.negate().div(other.negate());
    else return this.negate().div(other).negate();
  else if (other.isNegative()) return this.div(other.negate()).negate();
  var res = goog.math.Long.getZero();
  var rem = this;
  while (rem.greaterThanOrEqual(other)) {
    var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
    var log2 = Math.ceil(Math.log(approx) / Math.LN2);
    var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
    var approxRes = goog.math.Long.fromNumber(approx);
    var approxRem = approxRes.multiply(other);
    while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
      approx -= delta;
      approxRes = goog.math.Long.fromNumber(approx);
      approxRem = approxRes.multiply(other);
    }
    if (approxRes.isZero()) approxRes = goog.math.Long.getOne();
    res = res.add(approxRes);
    rem = rem.subtract(approxRem);
  }
  return res;
};
goog.math.Long.prototype.modulo = function(other) {
  return this.subtract(this.div(other).multiply(other));
};
goog.math.Long.prototype.not = function() {
  return goog.math.Long.fromBits(~this.low_, ~this.high_);
};
goog.math.Long.prototype.and = function(other) {
  return goog.math.Long.fromBits(
    this.low_ & other.low_,
    this.high_ & other.high_
  );
};
goog.math.Long.prototype.or = function(other) {
  return goog.math.Long.fromBits(
    this.low_ | other.low_,
    this.high_ | other.high_
  );
};
goog.math.Long.prototype.xor = function(other) {
  return goog.math.Long.fromBits(
    this.low_ ^ other.low_,
    this.high_ ^ other.high_
  );
};
goog.math.Long.prototype.shiftLeft = function(numBits) {
  numBits &= 63;
  if (numBits == 0)
    return this;
  else {
    var low = this.low_;
    if (numBits < 32) {
      var high = this.high_;
      return goog.math.Long.fromBits(
        low << numBits,
        high << numBits | low >>> 32 - numBits
      );
    } else
      return goog.math.Long.fromBits(0, low << numBits - 32);
  }
};
goog.math.Long.prototype.shiftRight = function(numBits) {
  numBits &= 63;
  if (numBits == 0)
    return this;
  else {
    var high = this.high_;
    if (numBits < 32) {
      var low = this.low_;
      return goog.math.Long.fromBits(
        low >>> numBits | high << 32 - numBits,
        high >> numBits
      );
    } else
      return goog.math.Long.fromBits(high >> numBits - 32, high >= 0 ? 0 : -1);
  }
};
goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {
  numBits &= 63;
  if (numBits == 0)
    return this;
  else {
    var high = this.high_;
    if (numBits < 32) {
      var low = this.low_;
      return goog.math.Long.fromBits(
        low >>> numBits | high << 32 - numBits,
        high >>> numBits
      );
    } else if (numBits == 32) return goog.math.Long.fromBits(high, 0);
    else return goog.math.Long.fromBits(high >>> numBits - 32, 0);
  }
};
goog.math.Long.ValueCacheId_ = {
  MAX_VALUE: 1,
  MIN_VALUE: 2,
  ZERO: 3,
  ONE: 4,
  NEG_ONE: 5,
  TWO_PWR_24: 6
};
goog.provide('cljs.core');
goog.require('goog.math.Long');
goog.require('goog.math.Integer');
goog.require('goog.string');
goog.require('goog.object');
goog.require('goog.array');
goog.require('goog.string.StringBuffer');
cljs.core._STAR_clojurescript_version_STAR_ = '1.9.473';
cljs.core._STAR_unchecked_if_STAR_ = false;
cljs.core._STAR_warn_on_infer_STAR_ = false;
if (typeof cljs.core.PROTOCOL_SENTINEL !== 'undefined');
else cljs.core.PROTOCOL_SENTINEL = {};
goog.define('cljs.core._STAR_target_STAR_', 'default');
cljs.core._STAR_ns_STAR_ = null;
cljs.core._STAR_out_STAR_ = null;
cljs.core._STAR_assert_STAR_ = true;
if (typeof cljs.core._STAR_print_fn_STAR_ !== 'undefined');
else
  cljs.core._STAR_print_fn_STAR_ = function cljs$core$_STAR_print_fn_STAR_(_) {
    throw new Error('No *print-fn* fn set for evaluation environment');
  };
if (typeof cljs.core._STAR_print_err_fn_STAR_ !== 'undefined');
else
  cljs.core._STAR_print_err_fn_STAR_ = function cljs$core$_STAR_print_err_fn_STAR_(
    _
  ) {
    throw new Error('No *print-err-fn* fn set for evaluation environment');
  };
cljs.core.set_print_fn_BANG_ = function cljs$core$set_print_fn_BANG_(f) {
  return (cljs.core._STAR_print_fn_STAR_ = f);
};
cljs.core.set_print_err_fn_BANG_ = function cljs$core$set_print_err_fn_BANG_(
  f
) {
  return (cljs.core._STAR_print_err_fn_STAR_ = f);
};
cljs.core._STAR_flush_on_newline_STAR_ = true;
cljs.core._STAR_print_newline_STAR_ = true;
cljs.core._STAR_print_readably_STAR_ = true;
cljs.core._STAR_print_meta_STAR_ = false;
cljs.core._STAR_print_dup_STAR_ = false;
cljs.core._STAR_print_namespace_maps_STAR_ = false;
cljs.core._STAR_print_length_STAR_ = null;
cljs.core._STAR_print_level_STAR_ = null;
if (typeof cljs.core._STAR_loaded_libs_STAR_ !== 'undefined');
else cljs.core._STAR_loaded_libs_STAR_ = null;
cljs.core.pr_opts = function cljs$core$pr_opts() {
  return new cljs.core.PersistentArrayMap(
    null,
    5,
    [
      new cljs.core.Keyword(
        null,
        'flush-on-newline',
        'flush-on-newline',
        -151457939
      ),
      cljs.core._STAR_flush_on_newline_STAR_,
      new cljs.core.Keyword(null, 'readably', 'readably', 1129599760),
      cljs.core._STAR_print_readably_STAR_,
      new cljs.core.Keyword(null, 'meta', 'meta', 1499536964),
      cljs.core._STAR_print_meta_STAR_,
      new cljs.core.Keyword(null, 'dup', 'dup', 556298533),
      cljs.core._STAR_print_dup_STAR_,
      new cljs.core.Keyword(null, 'print-length', 'print-length', 1931866356),
      cljs.core._STAR_print_length_STAR_
    ],
    null
  );
};
cljs.core.enable_console_print_BANG_ = function cljs$core$enable_console_print_BANG_() {
  cljs.core._STAR_print_newline_STAR_ = false;
  cljs.core._STAR_print_fn_STAR_ = (function() {
    var G__9453__delegate = function(args) {
      return console.log.apply(
        console,
        cljs.core.into_array.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)
          : cljs.core.into_array.call(null, args)
      );
    };
    var G__9453 = function(var_args) {
      var args = null;
      if (arguments.length > 0) {
        var G__9454__i = 0, G__9454__a = new Array(arguments.length - 0);
        while (G__9454__i < G__9454__a.length) {
          G__9454__a[G__9454__i] = arguments[G__9454__i + 0];
          ++G__9454__i;
        }
        args = new cljs.core.IndexedSeq(G__9454__a, 0);
      }
      return G__9453__delegate.call(this, args);
    };
    G__9453.cljs$lang$maxFixedArity = 0;
    G__9453.cljs$lang$applyTo = function(arglist__9455) {
      var args = cljs.core.seq(arglist__9455);
      return G__9453__delegate(args);
    };
    G__9453.cljs$core$IFn$_invoke$arity$variadic = G__9453__delegate;
    return G__9453;
  })();
  cljs.core._STAR_print_err_fn_STAR_ = (function() {
    var G__9456__delegate = function(args) {
      return console.error.apply(
        console,
        cljs.core.into_array.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)
          : cljs.core.into_array.call(null, args)
      );
    };
    var G__9456 = function(var_args) {
      var args = null;
      if (arguments.length > 0) {
        var G__9457__i = 0, G__9457__a = new Array(arguments.length - 0);
        while (G__9457__i < G__9457__a.length) {
          G__9457__a[G__9457__i] = arguments[G__9457__i + 0];
          ++G__9457__i;
        }
        args = new cljs.core.IndexedSeq(G__9457__a, 0);
      }
      return G__9456__delegate.call(this, args);
    };
    G__9456.cljs$lang$maxFixedArity = 0;
    G__9456.cljs$lang$applyTo = function(arglist__9458) {
      var args = cljs.core.seq(arglist__9458);
      return G__9456__delegate(args);
    };
    G__9456.cljs$core$IFn$_invoke$arity$variadic = G__9456__delegate;
    return G__9456;
  })();
  return null;
};
cljs.core.truth_ = function cljs$core$truth_(x) {
  return x != null && x !== false;
};
cljs.core.not_native = null;
cljs.core.identical_QMARK_ = function cljs$core$identical_QMARK_(x, y) {
  return x === y;
};
cljs.core.nil_QMARK_ = function cljs$core$nil_QMARK_(x) {
  return x == null;
};
cljs.core.array_QMARK_ = function cljs$core$array_QMARK_(x) {
  if (cljs.core._STAR_target_STAR_ === 'nodejs') return Array.isArray(x);
  else return x instanceof Array;
};
cljs.core.number_QMARK_ = function cljs$core$number_QMARK_(x) {
  return typeof x === 'number';
};
cljs.core.not = function cljs$core$not(x) {
  if (x == null) return true;
  else if (x === false) return true;
  else return false;
};
cljs.core.some_QMARK_ = function cljs$core$some_QMARK_(x) {
  return !(x == null);
};
cljs.core.object_QMARK_ = function cljs$core$object_QMARK_(x) {
  if (!(x == null)) return x.constructor === Object;
  else return false;
};
cljs.core.string_QMARK_ = function cljs$core$string_QMARK_(x) {
  return goog.isString(x);
};
cljs.core.char_QMARK_ = function cljs$core$char_QMARK_(x) {
  return typeof x === 'string' && 1 === x.length;
};
cljs.core.any_QMARK_ = function cljs$core$any_QMARK_(x) {
  return true;
};
cljs.core.native_satisfies_QMARK_ = function cljs$core$native_satisfies_QMARK_(
  p,
  x
) {
  var x__$1 = x == null ? null : x;
  if (p[goog.typeOf(x__$1)]) return true;
  else if (p['_']) return true;
  else return false;
};
cljs.core.is_proto_ = function cljs$core$is_proto_(x) {
  return x.constructor.prototype === x;
};
cljs.core._STAR_main_cli_fn_STAR_ = null;
cljs.core.type = function cljs$core$type(x) {
  if (x == null) return null;
  else return x.constructor;
};
cljs.core.missing_protocol = function cljs$core$missing_protocol(proto, obj) {
  var ty = cljs.core.type(obj);
  var ty__$1 = cljs.core.truth_(
    (function() {
      var and__7132__auto__ = ty;
      if (cljs.core.truth_(and__7132__auto__)) return ty.cljs$lang$type;
      else return and__7132__auto__;
    })()
  )
    ? ty.cljs$lang$ctorStr
    : goog.typeOf(obj);
  return new Error(
    [
      'No protocol method ',
      proto,
      ' defined for type ',
      ty__$1,
      ': ',
      obj
    ].join('')
  );
};
cljs.core.type__GT_str = function cljs$core$type__GT_str(ty) {
  var temp__4655__auto__ = ty.cljs$lang$ctorStr;
  if (cljs.core.truth_(temp__4655__auto__)) {
    var s = temp__4655__auto__;
    return s;
  } else
    return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ty)].join('');
};
cljs.core.load_file = function cljs$core$load_file(file) {
  if (cljs.core.truth_(COMPILED)) return null;
  else return goog.nodeGlobalRequire(file);
};
if (typeof Symbol !== 'undefined' && goog.typeOf(Symbol) === 'function')
  cljs.core.ITER_SYMBOL = Symbol.iterator;
else
  cljs.core.ITER_SYMBOL = '@@iterator';
cljs.core.CHAR_MAP = {
  ']': '_RBRACK_',
  "'": '_SINGLEQUOTE_',
  '\x3d': '_EQ_',
  '"': '_DOUBLEQUOTE_',
  '!': '_BANG_',
  '*': '_STAR_',
  '%': '_PERCENT_',
  '|': '_BAR_',
  '~': '_TILDE_',
  '/': '_SLASH_',
  '\\': '_BSLASH_',
  '-': '_',
  '?': '_QMARK_',
  '\x26': '_AMPERSAND_',
  ':': '_COLON_',
  '\x3c': '_LT_',
  '{': '_LBRACE_',
  '}': '_RBRACE_',
  '[': '_LBRACK_',
  '#': '_SHARP_',
  '^': '_CARET_',
  '+': '_PLUS_',
  '@': '_CIRCA_',
  '\x3e': '_GT_'
};
cljs.core.DEMUNGE_MAP = {
  _RBRACE_: '}',
  _COLON_: ':',
  _BANG_: '!',
  _QMARK_: '?',
  _BSLASH_: '\\\\',
  _SLASH_: '/',
  _PERCENT_: '%',
  _PLUS_: '+',
  _SHARP_: '#',
  _LBRACE_: '{',
  _BAR_: '|',
  _LBRACK_: '[',
  _EQ_: '\x3d',
  _: '-',
  _TILDE_: '~',
  _RBRACK_: ']',
  _GT_: '\x3e',
  _SINGLEQUOTE_: "'",
  _CIRCA_: '@',
  _AMPERSAND_: '\x26',
  _DOUBLEQUOTE_: '\\"',
  _CARET_: '^',
  _LT_: '\x3c',
  _STAR_: '*'
};
cljs.core.DEMUNGE_PATTERN = null;
cljs.core.system_time = function cljs$core$system_time() {
  if (typeof performance !== 'undefined' && !(performance.now == null))
    return performance.now();
  else if (typeof process !== 'undefined' && !(process.hrtime == null)) {
    var t = process.hrtime();
    return (t[0] * 1e9 + t[1]) / 1e6;
  } else
    return new Date().getTime();
};
cljs.core.make_array = function cljs$core$make_array(var_args) {
  var args9459 = [];
  var len__8257__auto___9465 = arguments.length;
  var i__8258__auto___9466 = 0;
  while (true) {
    if (i__8258__auto___9466 < len__8257__auto___9465) {
      args9459.push(arguments[i__8258__auto___9466]);
      var G__9467 = i__8258__auto___9466 + 1;
      i__8258__auto___9466 = G__9467;
      continue;
    } else;
    break;
  }
  var G__9464 = args9459.length;
  switch (G__9464) {
    case 1:
      return cljs.core.make_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.make_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9459.slice(2),
        0,
        null
      );
      return cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.make_array.cljs$core$IFn$_invoke$arity$1 = function(size) {
  return new Array(size);
};
cljs.core.make_array.cljs$core$IFn$_invoke$arity$2 = function(type, size) {
  return new Array(size);
};
cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic = function(
  type,
  size,
  more_sizes
) {
  var dims = more_sizes;
  var dimarray = new Array(size);
  var n__8067__auto___9469 = dimarray.length;
  var i_9470 = 0;
  while (true) {
    if (i_9470 < n__8067__auto___9469) {
      dimarray[i_9470] = cljs.core.apply.cljs$core$IFn$_invoke$arity$3
        ? cljs.core.apply.cljs$core$IFn$_invoke$arity$3(
            cljs.core.make_array,
            null,
            dims
          )
        : cljs.core.apply.call(null, cljs.core.make_array, null, dims);
      var G__9471 = i_9470 + 1;
      i_9470 = G__9471;
      continue;
    } else;
    break;
  }
  return dimarray;
};
cljs.core.make_array.cljs$lang$applyTo = function(seq9460) {
  var G__9461 = cljs.core.first(seq9460);
  var seq9460__$1 = cljs.core.next(seq9460);
  var G__9462 = cljs.core.first(seq9460__$1);
  var seq9460__$2 = cljs.core.next(seq9460__$1);
  return cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic(
    G__9461,
    G__9462,
    seq9460__$2
  );
};
cljs.core.make_array.cljs$lang$maxFixedArity = 2;
cljs.core.aclone = function cljs$core$aclone(arr) {
  var len = arr.length;
  var new_arr = new Array(len);
  var n__8067__auto___9472 = len;
  var i_9473 = 0;
  while (true) {
    if (i_9473 < n__8067__auto___9472) {
      new_arr[i_9473] = arr[i_9473];
      var G__9474 = i_9473 + 1;
      i_9473 = G__9474;
      continue;
    } else;
    break;
  }
  return new_arr;
};
cljs.core.array = function cljs$core$array(var_args) {
  var a = new Array(arguments.length);
  var i = 0;
  while (true) {
    if (i < a.length) {
      a[i] = arguments[i];
      var G__9475 = i + 1;
      i = G__9475;
      continue;
    } else
      return a;
    break;
  }
};
cljs.core.aget = function cljs$core$aget(var_args) {
  var args9476 = [];
  var len__8257__auto___9485 = arguments.length;
  var i__8258__auto___9486 = 0;
  while (true) {
    if (i__8258__auto___9486 < len__8257__auto___9485) {
      args9476.push(arguments[i__8258__auto___9486]);
      var G__9487 = i__8258__auto___9486 + 1;
      i__8258__auto___9486 = G__9487;
      continue;
    } else;
    break;
  }
  var G__9481 = args9476.length;
  switch (G__9481) {
    case 2:
      return cljs.core.aget.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9476.slice(2),
        0,
        null
      );
      return cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.aget.cljs$core$IFn$_invoke$arity$2 = function(array, i) {
  return array[i];
};
cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic = function(array, i, idxs) {
  var G__9482 = cljs.core.aget;
  var G__9483 = array[i];
  var G__9484 = idxs;
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$3
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$3(G__9482, G__9483, G__9484)
    : cljs.core.apply.call(null, G__9482, G__9483, G__9484);
};
cljs.core.aget.cljs$lang$applyTo = function(seq9477) {
  var G__9478 = cljs.core.first(seq9477);
  var seq9477__$1 = cljs.core.next(seq9477);
  var G__9479 = cljs.core.first(seq9477__$1);
  var seq9477__$2 = cljs.core.next(seq9477__$1);
  return cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic(
    G__9478,
    G__9479,
    seq9477__$2
  );
};
cljs.core.aget.cljs$lang$maxFixedArity = 2;
cljs.core.aset = function cljs$core$aset(var_args) {
  var args9489 = [];
  var len__8257__auto___9500 = arguments.length;
  var i__8258__auto___9501 = 0;
  while (true) {
    if (i__8258__auto___9501 < len__8257__auto___9500) {
      args9489.push(arguments[i__8258__auto___9501]);
      var G__9502 = i__8258__auto___9501 + 1;
      i__8258__auto___9501 = G__9502;
      continue;
    } else;
    break;
  }
  var G__9495 = args9489.length;
  switch (G__9495) {
    case 3:
      return cljs.core.aset.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9489.slice(3),
        0,
        null
      );
      return cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.aset.cljs$core$IFn$_invoke$arity$3 = function(array, i, val) {
  return (array[i] = val);
};
cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic = function(
  array,
  idx,
  idx2,
  idxv
) {
  var G__9496 = cljs.core.aset;
  var G__9497 = array[idx];
  var G__9498 = idx2;
  var G__9499 = idxv;
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$4
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$4(
        G__9496,
        G__9497,
        G__9498,
        G__9499
      )
    : cljs.core.apply.call(null, G__9496, G__9497, G__9498, G__9499);
};
cljs.core.aset.cljs$lang$applyTo = function(seq9490) {
  var G__9491 = cljs.core.first(seq9490);
  var seq9490__$1 = cljs.core.next(seq9490);
  var G__9492 = cljs.core.first(seq9490__$1);
  var seq9490__$2 = cljs.core.next(seq9490__$1);
  var G__9493 = cljs.core.first(seq9490__$2);
  var seq9490__$3 = cljs.core.next(seq9490__$2);
  return cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic(
    G__9491,
    G__9492,
    G__9493,
    seq9490__$3
  );
};
cljs.core.aset.cljs$lang$maxFixedArity = 3;
cljs.core.alength = function cljs$core$alength(array) {
  return array.length;
};
cljs.core.into_array = function cljs$core$into_array(var_args) {
  var args9504 = [];
  var len__8257__auto___9510 = arguments.length;
  var i__8258__auto___9511 = 0;
  while (true) {
    if (i__8258__auto___9511 < len__8257__auto___9510) {
      args9504.push(arguments[i__8258__auto___9511]);
      var G__9512 = i__8258__auto___9511 + 1;
      i__8258__auto___9511 = G__9512;
      continue;
    } else;
    break;
  }
  var G__9506 = args9504.length;
  switch (G__9506) {
    case 1:
      return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.into_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9504.length)
        ].join('')
      );
  }
};
cljs.core.into_array.cljs$core$IFn$_invoke$arity$1 = function(aseq) {
  return cljs.core.into_array.cljs$core$IFn$_invoke$arity$2(null, aseq);
};
cljs.core.into_array.cljs$core$IFn$_invoke$arity$2 = function(type, aseq) {
  var G__9507 = function(a, x) {
    a.push(x);
    return a;
  };
  var G__9508 = [];
  var G__9509 = aseq;
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3
    ? cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(G__9507, G__9508, G__9509)
    : cljs.core.reduce.call(null, G__9507, G__9508, G__9509);
};
cljs.core.into_array.cljs$lang$maxFixedArity = 2;
cljs.core.js_invoke = function cljs$core$js_invoke(var_args) {
  var args__8264__auto__ = [];
  var len__8257__auto___9517 = arguments.length;
  var i__8258__auto___9518 = 0;
  while (true) {
    if (i__8258__auto___9518 < len__8257__auto___9517) {
      args__8264__auto__.push(arguments[i__8258__auto___9518]);
      var G__9519 = i__8258__auto___9518 + 1;
      i__8258__auto___9518 = G__9519;
      continue;
    } else;
    break;
  }
  var argseq__8265__auto__ = 2 < args__8264__auto__.length
    ? new cljs.core.IndexedSeq(args__8264__auto__.slice(2), 0, null)
    : null;
  return cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic(
    arguments[0],
    arguments[1],
    argseq__8265__auto__
  );
};
cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic = function(
  obj,
  s,
  args
) {
  return obj[s].apply(
    obj,
    cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)
  );
};
cljs.core.js_invoke.cljs$lang$maxFixedArity = 2;
cljs.core.js_invoke.cljs$lang$applyTo = function(seq9514) {
  var G__9515 = cljs.core.first(seq9514);
  var seq9514__$1 = cljs.core.next(seq9514);
  var G__9516 = cljs.core.first(seq9514__$1);
  var seq9514__$2 = cljs.core.next(seq9514__$1);
  return cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic(
    G__9515,
    G__9516,
    seq9514__$2
  );
};
cljs.core.Fn = function() {};
cljs.core.IFn = function() {};
cljs.core._invoke = function cljs$core$_invoke(var_args) {
  var args9520 = [];
  var len__8257__auto___9523 = arguments.length;
  var i__8258__auto___9524 = 0;
  while (true) {
    if (i__8258__auto___9524 < len__8257__auto___9523) {
      args9520.push(arguments[i__8258__auto___9524]);
      var G__9525 = i__8258__auto___9524 + 1;
      i__8258__auto___9524 = G__9525;
      continue;
    } else;
    break;
  }
  var G__9522 = args9520.length;
  switch (G__9522) {
    case 1:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    case 6:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$6(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5]
      );
      break;
    case 7:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$7(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6]
      );
      break;
    case 8:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$8(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7]
      );
      break;
    case 9:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$9(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8]
      );
      break;
    case 10:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$10(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9]
      );
      break;
    case 11:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$11(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10]
      );
      break;
    case 12:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$12(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11]
      );
      break;
    case 13:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$13(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12]
      );
      break;
    case 14:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$14(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13]
      );
      break;
    case 15:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$15(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14]
      );
      break;
    case 16:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$16(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15]
      );
      break;
    case 17:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$17(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16]
      );
      break;
    case 18:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$18(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16],
        arguments[17]
      );
      break;
    case 19:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$19(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16],
        arguments[17],
        arguments[18]
      );
      break;
    case 20:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$20(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16],
        arguments[17],
        arguments[18],
        arguments[19]
      );
      break;
    case 21:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$21(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16],
        arguments[17],
        arguments[18],
        arguments[19],
        arguments[20]
      );
      break;
    case 22:
      return cljs.core._invoke.cljs$core$IFn$_invoke$arity$22(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        arguments[6],
        arguments[7],
        arguments[8],
        arguments[9],
        arguments[10],
        arguments[11],
        arguments[12],
        arguments[13],
        arguments[14],
        arguments[15],
        arguments[16],
        arguments[17],
        arguments[18],
        arguments[19],
        arguments[20],
        arguments[21]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9520.length)
        ].join('')
      );
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$1 = function(this$) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$1 == null))
    return this$.cljs$core$IFn$_invoke$arity$1(this$);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(this$)
        : m__7813__auto__.call(null, this$);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(this$)
          : m__7813__auto____$1.call(null, this$);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$2 = function(this$, a) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$2 == null))
    return this$.cljs$core$IFn$_invoke$arity$2(this$, a);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(this$, a)
        : m__7813__auto__.call(null, this$, a);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(this$, a)
          : m__7813__auto____$1.call(null, this$, a);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$3 = function(this$, a, b) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$3 == null))
    return this$.cljs$core$IFn$_invoke$arity$3(this$, a, b);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(this$, a, b)
        : m__7813__auto__.call(null, this$, a, b);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(this$, a, b)
          : m__7813__auto____$1.call(null, this$, a, b);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$4 = function(this$, a, b, c) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$4 == null))
    return this$.cljs$core$IFn$_invoke$arity$4(this$, a, b, c);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$4
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$4(this$, a, b, c)
        : m__7813__auto__.call(null, this$, a, b, c);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$4
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$4(this$, a, b, c)
          : m__7813__auto____$1.call(null, this$, a, b, c);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$5 = function(this$, a, b, c, d) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$5 == null))
    return this$.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$5
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d)
        : m__7813__auto__.call(null, this$, a, b, c, d);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$5
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d)
          : m__7813__auto____$1.call(null, this$, a, b, c, d);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$6 = function(
  this$,
  a,
  b,
  c,
  d,
  e
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$6 == null))
    return this$.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$6
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e)
        : m__7813__auto__.call(null, this$, a, b, c, d, e);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$6
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$6(
              this$,
              a,
              b,
              c,
              d,
              e
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$7 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$7 == null))
    return this$.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$7
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f)
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$7
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$7(
              this$,
              a,
              b,
              c,
              d,
              e,
              f
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e, f);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$8 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$8 == null))
    return this$.cljs$core$IFn$_invoke$arity$8(this$, a, b, c, d, e, f, g);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$8
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$8(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$8
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$8(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e, f, g);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$9 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$9 == null))
    return this$.cljs$core$IFn$_invoke$arity$9(this$, a, b, c, d, e, f, g, h);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$9
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$9(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g, h);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$9
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$9(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e, f, g, h);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$10 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$10 == null))
    return this$.cljs$core$IFn$_invoke$arity$10(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$10
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$10(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g, h, i);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$10
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$10(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e, f, g, h, i);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$11 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$11 == null))
    return this$.cljs$core$IFn$_invoke$arity$11(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$11
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$11(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g, h, i, j);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$11
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$11(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j
            )
          : m__7813__auto____$1.call(null, this$, a, b, c, d, e, f, g, h, i, j);
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$12 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$12 == null))
    return this$.cljs$core$IFn$_invoke$arity$12(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$12
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$12(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g, h, i, j, k);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$12
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$12(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$13 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$13 == null))
    return this$.cljs$core$IFn$_invoke$arity$13(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$13
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$13(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l
          )
        : m__7813__auto__.call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l);
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$13
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$13(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$14 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$14 == null))
    return this$.cljs$core$IFn$_invoke$arity$14(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$14
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$14(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$14
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$14(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$15 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$15 == null))
    return this$.cljs$core$IFn$_invoke$arity$15(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$15
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$15(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$15
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$15(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$16 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$16 == null))
    return this$.cljs$core$IFn$_invoke$arity$16(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$16
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$16(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$16
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$16(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$17 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$17 == null))
    return this$.cljs$core$IFn$_invoke$arity$17(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$17
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$17(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$17
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$17(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$18 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$18 == null))
    return this$.cljs$core$IFn$_invoke$arity$18(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$18
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$18(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$18
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$18(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$19 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$19 == null))
    return this$.cljs$core$IFn$_invoke$arity$19(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$19
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$19(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$19
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$19(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$20 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$20 == null))
    return this$.cljs$core$IFn$_invoke$arity$20(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r,
      s
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$20
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$20(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$20
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$20(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$21 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$21 == null))
    return this$.cljs$core$IFn$_invoke$arity$21(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r,
      s,
      t
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$21
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$21(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s,
            t
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s,
            t
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$21
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$21(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$core$IFn$_invoke$arity$22 = function(
  this$,
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t,
  rest
) {
  if (!(this$ == null) && !(this$.cljs$core$IFn$_invoke$arity$22 == null))
    return this$.cljs$core$IFn$_invoke$arity$22(
      this$,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r,
      s,
      t,
      rest
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._invoke[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$22
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$22(
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s,
            t,
            rest
          )
        : m__7813__auto__.call(
            null,
            this$,
            a,
            b,
            c,
            d,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s,
            t,
            rest
          );
    else {
      var m__7813__auto____$1 = cljs.core._invoke['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$22
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$22(
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t,
              rest
            )
          : m__7813__auto____$1.call(
              null,
              this$,
              a,
              b,
              c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t,
              rest
            );
      else
        throw cljs.core.missing_protocol('IFn.-invoke', this$);
    }
  }
};
cljs.core._invoke.cljs$lang$maxFixedArity = 22;
cljs.core.ICloneable = function() {};
cljs.core._clone = function cljs$core$_clone(value) {
  if (!(value == null) && !(value.cljs$core$ICloneable$_clone$arity$1 == null))
    return value.cljs$core$ICloneable$_clone$arity$1(value);
  else {
    var x__7812__auto__ = value == null ? null : value;
    var m__7813__auto__ = cljs.core._clone[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(value)
        : m__7813__auto__.call(null, value);
    else {
      var m__7813__auto____$1 = cljs.core._clone['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(value)
          : m__7813__auto____$1.call(null, value);
      else
        throw cljs.core.missing_protocol('ICloneable.-clone', value);
    }
  }
};
cljs.core.ICounted = function() {};
cljs.core._count = function cljs$core$_count(coll) {
  if (!(coll == null) && !(coll.cljs$core$ICounted$_count$arity$1 == null))
    return coll.cljs$core$ICounted$_count$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._count[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._count['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('ICounted.-count', coll);
    }
  }
};
cljs.core.IEmptyableCollection = function() {};
cljs.core._empty = function cljs$core$_empty(coll) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IEmptyableCollection$_empty$arity$1 == null)
  )
    return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._empty[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._empty['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IEmptyableCollection.-empty', coll);
    }
  }
};
cljs.core.ICollection = function() {};
cljs.core._conj = function cljs$core$_conj(coll, o) {
  if (!(coll == null) && !(coll.cljs$core$ICollection$_conj$arity$2 == null))
    return coll.cljs$core$ICollection$_conj$arity$2(coll, o);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._conj[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, o)
        : m__7813__auto__.call(null, coll, o);
    else {
      var m__7813__auto____$1 = cljs.core._conj['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, o)
          : m__7813__auto____$1.call(null, coll, o);
      else
        throw cljs.core.missing_protocol('ICollection.-conj', coll);
    }
  }
};
cljs.core.IIndexed = function() {};
cljs.core._nth = function cljs$core$_nth(var_args) {
  var args9527 = [];
  var len__8257__auto___9530 = arguments.length;
  var i__8258__auto___9531 = 0;
  while (true) {
    if (i__8258__auto___9531 < len__8257__auto___9530) {
      args9527.push(arguments[i__8258__auto___9531]);
      var G__9532 = i__8258__auto___9531 + 1;
      i__8258__auto___9531 = G__9532;
      continue;
    } else;
    break;
  }
  var G__9529 = args9527.length;
  switch (G__9529) {
    case 2:
      return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9527.length)
        ].join('')
      );
  }
};
cljs.core._nth.cljs$core$IFn$_invoke$arity$2 = function(coll, n) {
  if (!(coll == null) && !(coll.cljs$core$IIndexed$_nth$arity$2 == null))
    return coll.cljs$core$IIndexed$_nth$arity$2(coll, n);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._nth[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, n)
        : m__7813__auto__.call(null, coll, n);
    else {
      var m__7813__auto____$1 = cljs.core._nth['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, n)
          : m__7813__auto____$1.call(null, coll, n);
      else
        throw cljs.core.missing_protocol('IIndexed.-nth', coll);
    }
  }
};
cljs.core._nth.cljs$core$IFn$_invoke$arity$3 = function(coll, n, not_found) {
  if (!(coll == null) && !(coll.cljs$core$IIndexed$_nth$arity$3 == null))
    return coll.cljs$core$IIndexed$_nth$arity$3(coll, n, not_found);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._nth[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(coll, n, not_found)
        : m__7813__auto__.call(null, coll, n, not_found);
    else {
      var m__7813__auto____$1 = cljs.core._nth['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(
              coll,
              n,
              not_found
            )
          : m__7813__auto____$1.call(null, coll, n, not_found);
      else
        throw cljs.core.missing_protocol('IIndexed.-nth', coll);
    }
  }
};
cljs.core._nth.cljs$lang$maxFixedArity = 3;
cljs.core.ASeq = function() {};
cljs.core.ISeq = function() {};
cljs.core._first = function cljs$core$_first(coll) {
  if (!(coll == null) && !(coll.cljs$core$ISeq$_first$arity$1 == null))
    return coll.cljs$core$ISeq$_first$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._first[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._first['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('ISeq.-first', coll);
    }
  }
};
cljs.core._rest = function cljs$core$_rest(coll) {
  if (!(coll == null) && !(coll.cljs$core$ISeq$_rest$arity$1 == null))
    return coll.cljs$core$ISeq$_rest$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._rest[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._rest['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('ISeq.-rest', coll);
    }
  }
};
cljs.core.INext = function() {};
cljs.core._next = function cljs$core$_next(coll) {
  if (!(coll == null) && !(coll.cljs$core$INext$_next$arity$1 == null))
    return coll.cljs$core$INext$_next$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._next[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._next['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('INext.-next', coll);
    }
  }
};
cljs.core.ILookup = function() {};
cljs.core._lookup = function cljs$core$_lookup(var_args) {
  var args9534 = [];
  var len__8257__auto___9537 = arguments.length;
  var i__8258__auto___9538 = 0;
  while (true) {
    if (i__8258__auto___9538 < len__8257__auto___9537) {
      args9534.push(arguments[i__8258__auto___9538]);
      var G__9539 = i__8258__auto___9538 + 1;
      i__8258__auto___9538 = G__9539;
      continue;
    } else;
    break;
  }
  var G__9536 = args9534.length;
  switch (G__9536) {
    case 2:
      return cljs.core._lookup.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9534.length)
        ].join('')
      );
  }
};
cljs.core._lookup.cljs$core$IFn$_invoke$arity$2 = function(o, k) {
  if (!(o == null) && !(o.cljs$core$ILookup$_lookup$arity$2 == null))
    return o.cljs$core$ILookup$_lookup$arity$2(o, k);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._lookup[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, k)
        : m__7813__auto__.call(null, o, k);
    else {
      var m__7813__auto____$1 = cljs.core._lookup['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, k)
          : m__7813__auto____$1.call(null, o, k);
      else
        throw cljs.core.missing_protocol('ILookup.-lookup', o);
    }
  }
};
cljs.core._lookup.cljs$core$IFn$_invoke$arity$3 = function(o, k, not_found) {
  if (!(o == null) && !(o.cljs$core$ILookup$_lookup$arity$3 == null))
    return o.cljs$core$ILookup$_lookup$arity$3(o, k, not_found);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._lookup[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(o, k, not_found)
        : m__7813__auto__.call(null, o, k, not_found);
    else {
      var m__7813__auto____$1 = cljs.core._lookup['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(o, k, not_found)
          : m__7813__auto____$1.call(null, o, k, not_found);
      else
        throw cljs.core.missing_protocol('ILookup.-lookup', o);
    }
  }
};
cljs.core._lookup.cljs$lang$maxFixedArity = 3;
cljs.core.IAssociative = function() {};
cljs.core._contains_key_QMARK_ = function cljs$core$_contains_key_QMARK_(
  coll,
  k
) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 == null)
  )
    return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll, k);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._contains_key_QMARK_[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, k)
        : m__7813__auto__.call(null, coll, k);
    else {
      var m__7813__auto____$1 = cljs.core._contains_key_QMARK_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, k)
          : m__7813__auto____$1.call(null, coll, k);
      else
        throw cljs.core.missing_protocol('IAssociative.-contains-key?', coll);
    }
  }
};
cljs.core._assoc = function cljs$core$_assoc(coll, k, v) {
  if (!(coll == null) && !(coll.cljs$core$IAssociative$_assoc$arity$3 == null))
    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, k, v);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._assoc[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(coll, k, v)
        : m__7813__auto__.call(null, coll, k, v);
    else {
      var m__7813__auto____$1 = cljs.core._assoc['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(coll, k, v)
          : m__7813__auto____$1.call(null, coll, k, v);
      else
        throw cljs.core.missing_protocol('IAssociative.-assoc', coll);
    }
  }
};
cljs.core.IMap = function() {};
cljs.core._dissoc = function cljs$core$_dissoc(coll, k) {
  if (!(coll == null) && !(coll.cljs$core$IMap$_dissoc$arity$2 == null))
    return coll.cljs$core$IMap$_dissoc$arity$2(coll, k);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._dissoc[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, k)
        : m__7813__auto__.call(null, coll, k);
    else {
      var m__7813__auto____$1 = cljs.core._dissoc['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, k)
          : m__7813__auto____$1.call(null, coll, k);
      else
        throw cljs.core.missing_protocol('IMap.-dissoc', coll);
    }
  }
};
cljs.core.IMapEntry = function() {};
cljs.core._key = function cljs$core$_key(coll) {
  if (!(coll == null) && !(coll.cljs$core$IMapEntry$_key$arity$1 == null))
    return coll.cljs$core$IMapEntry$_key$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._key[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._key['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IMapEntry.-key', coll);
    }
  }
};
cljs.core._val = function cljs$core$_val(coll) {
  if (!(coll == null) && !(coll.cljs$core$IMapEntry$_val$arity$1 == null))
    return coll.cljs$core$IMapEntry$_val$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._val[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._val['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IMapEntry.-val', coll);
    }
  }
};
cljs.core.ISet = function() {};
cljs.core._disjoin = function cljs$core$_disjoin(coll, v) {
  if (!(coll == null) && !(coll.cljs$core$ISet$_disjoin$arity$2 == null))
    return coll.cljs$core$ISet$_disjoin$arity$2(coll, v);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._disjoin[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, v)
        : m__7813__auto__.call(null, coll, v);
    else {
      var m__7813__auto____$1 = cljs.core._disjoin['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, v)
          : m__7813__auto____$1.call(null, coll, v);
      else
        throw cljs.core.missing_protocol('ISet.-disjoin', coll);
    }
  }
};
cljs.core.IStack = function() {};
cljs.core._peek = function cljs$core$_peek(coll) {
  if (!(coll == null) && !(coll.cljs$core$IStack$_peek$arity$1 == null))
    return coll.cljs$core$IStack$_peek$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._peek[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._peek['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IStack.-peek', coll);
    }
  }
};
cljs.core._pop = function cljs$core$_pop(coll) {
  if (!(coll == null) && !(coll.cljs$core$IStack$_pop$arity$1 == null))
    return coll.cljs$core$IStack$_pop$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._pop[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._pop['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IStack.-pop', coll);
    }
  }
};
cljs.core.IVector = function() {};
cljs.core._assoc_n = function cljs$core$_assoc_n(coll, n, val) {
  if (!(coll == null) && !(coll.cljs$core$IVector$_assoc_n$arity$3 == null))
    return coll.cljs$core$IVector$_assoc_n$arity$3(coll, n, val);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._assoc_n[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(coll, n, val)
        : m__7813__auto__.call(null, coll, n, val);
    else {
      var m__7813__auto____$1 = cljs.core._assoc_n['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(coll, n, val)
          : m__7813__auto____$1.call(null, coll, n, val);
      else
        throw cljs.core.missing_protocol('IVector.-assoc-n', coll);
    }
  }
};
cljs.core.IDeref = function() {};
cljs.core._deref = function cljs$core$_deref(o) {
  if (!(o == null) && !(o.cljs$core$IDeref$_deref$arity$1 == null))
    return o.cljs$core$IDeref$_deref$arity$1(o);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._deref[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(o)
        : m__7813__auto__.call(null, o);
    else {
      var m__7813__auto____$1 = cljs.core._deref['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(o)
          : m__7813__auto____$1.call(null, o);
      else
        throw cljs.core.missing_protocol('IDeref.-deref', o);
    }
  }
};
cljs.core.IDerefWithTimeout = function() {};
cljs.core._deref_with_timeout = function cljs$core$_deref_with_timeout(
  o,
  msec,
  timeout_val
) {
  if (
    !(o == null) &&
    !(o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3 == null)
  )
    return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(
      o,
      msec,
      timeout_val
    );
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._deref_with_timeout[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(o, msec, timeout_val)
        : m__7813__auto__.call(null, o, msec, timeout_val);
    else {
      var m__7813__auto____$1 = cljs.core._deref_with_timeout['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(
              o,
              msec,
              timeout_val
            )
          : m__7813__auto____$1.call(null, o, msec, timeout_val);
      else
        throw cljs.core.missing_protocol(
          'IDerefWithTimeout.-deref-with-timeout',
          o
        );
    }
  }
};
cljs.core.IMeta = function() {};
cljs.core._meta = function cljs$core$_meta(o) {
  if (!(o == null) && !(o.cljs$core$IMeta$_meta$arity$1 == null))
    return o.cljs$core$IMeta$_meta$arity$1(o);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._meta[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(o)
        : m__7813__auto__.call(null, o);
    else {
      var m__7813__auto____$1 = cljs.core._meta['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(o)
          : m__7813__auto____$1.call(null, o);
      else
        throw cljs.core.missing_protocol('IMeta.-meta', o);
    }
  }
};
cljs.core.IWithMeta = function() {};
cljs.core._with_meta = function cljs$core$_with_meta(o, meta) {
  if (!(o == null) && !(o.cljs$core$IWithMeta$_with_meta$arity$2 == null))
    return o.cljs$core$IWithMeta$_with_meta$arity$2(o, meta);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._with_meta[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, meta)
        : m__7813__auto__.call(null, o, meta);
    else {
      var m__7813__auto____$1 = cljs.core._with_meta['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, meta)
          : m__7813__auto____$1.call(null, o, meta);
      else
        throw cljs.core.missing_protocol('IWithMeta.-with-meta', o);
    }
  }
};
cljs.core.IReduce = function() {};
cljs.core._reduce = function cljs$core$_reduce(var_args) {
  var args9541 = [];
  var len__8257__auto___9544 = arguments.length;
  var i__8258__auto___9545 = 0;
  while (true) {
    if (i__8258__auto___9545 < len__8257__auto___9544) {
      args9541.push(arguments[i__8258__auto___9545]);
      var G__9546 = i__8258__auto___9545 + 1;
      i__8258__auto___9545 = G__9546;
      continue;
    } else;
    break;
  }
  var G__9543 = args9541.length;
  switch (G__9543) {
    case 2:
      return cljs.core._reduce.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._reduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9541.length)
        ].join('')
      );
  }
};
cljs.core._reduce.cljs$core$IFn$_invoke$arity$2 = function(coll, f) {
  if (!(coll == null) && !(coll.cljs$core$IReduce$_reduce$arity$2 == null))
    return coll.cljs$core$IReduce$_reduce$arity$2(coll, f);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._reduce[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, f)
        : m__7813__auto__.call(null, coll, f);
    else {
      var m__7813__auto____$1 = cljs.core._reduce['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, f)
          : m__7813__auto____$1.call(null, coll, f);
      else
        throw cljs.core.missing_protocol('IReduce.-reduce', coll);
    }
  }
};
cljs.core._reduce.cljs$core$IFn$_invoke$arity$3 = function(coll, f, start) {
  if (!(coll == null) && !(coll.cljs$core$IReduce$_reduce$arity$3 == null))
    return coll.cljs$core$IReduce$_reduce$arity$3(coll, f, start);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._reduce[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(coll, f, start)
        : m__7813__auto__.call(null, coll, f, start);
    else {
      var m__7813__auto____$1 = cljs.core._reduce['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(coll, f, start)
          : m__7813__auto____$1.call(null, coll, f, start);
      else
        throw cljs.core.missing_protocol('IReduce.-reduce', coll);
    }
  }
};
cljs.core._reduce.cljs$lang$maxFixedArity = 3;
cljs.core.IKVReduce = function() {};
cljs.core._kv_reduce = function cljs$core$_kv_reduce(coll, f, init) {
  if (!(coll == null) && !(coll.cljs$core$IKVReduce$_kv_reduce$arity$3 == null))
    return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll, f, init);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._kv_reduce[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(coll, f, init)
        : m__7813__auto__.call(null, coll, f, init);
    else {
      var m__7813__auto____$1 = cljs.core._kv_reduce['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(coll, f, init)
          : m__7813__auto____$1.call(null, coll, f, init);
      else
        throw cljs.core.missing_protocol('IKVReduce.-kv-reduce', coll);
    }
  }
};
cljs.core.IEquiv = function() {};
cljs.core._equiv = function cljs$core$_equiv(o, other) {
  if (!(o == null) && !(o.cljs$core$IEquiv$_equiv$arity$2 == null))
    return o.cljs$core$IEquiv$_equiv$arity$2(o, other);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._equiv[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, other)
        : m__7813__auto__.call(null, o, other);
    else {
      var m__7813__auto____$1 = cljs.core._equiv['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, other)
          : m__7813__auto____$1.call(null, o, other);
      else
        throw cljs.core.missing_protocol('IEquiv.-equiv', o);
    }
  }
};
cljs.core.IHash = function() {};
cljs.core._hash = function cljs$core$_hash(o) {
  if (!(o == null) && !(o.cljs$core$IHash$_hash$arity$1 == null))
    return o.cljs$core$IHash$_hash$arity$1(o);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._hash[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(o)
        : m__7813__auto__.call(null, o);
    else {
      var m__7813__auto____$1 = cljs.core._hash['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(o)
          : m__7813__auto____$1.call(null, o);
      else
        throw cljs.core.missing_protocol('IHash.-hash', o);
    }
  }
};
cljs.core.ISeqable = function() {};
cljs.core._seq = function cljs$core$_seq(o) {
  if (!(o == null) && !(o.cljs$core$ISeqable$_seq$arity$1 == null))
    return o.cljs$core$ISeqable$_seq$arity$1(o);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._seq[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(o)
        : m__7813__auto__.call(null, o);
    else {
      var m__7813__auto____$1 = cljs.core._seq['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(o)
          : m__7813__auto____$1.call(null, o);
      else
        throw cljs.core.missing_protocol('ISeqable.-seq', o);
    }
  }
};
cljs.core.ISequential = function() {};
cljs.core.IList = function() {};
cljs.core.IRecord = function() {};
cljs.core.IReversible = function() {};
cljs.core._rseq = function cljs$core$_rseq(coll) {
  if (!(coll == null) && !(coll.cljs$core$IReversible$_rseq$arity$1 == null))
    return coll.cljs$core$IReversible$_rseq$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._rseq[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._rseq['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IReversible.-rseq', coll);
    }
  }
};
cljs.core.ISorted = function() {};
cljs.core._sorted_seq = function cljs$core$_sorted_seq(coll, ascending_QMARK_) {
  if (!(coll == null) && !(coll.cljs$core$ISorted$_sorted_seq$arity$2 == null))
    return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll, ascending_QMARK_);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._sorted_seq[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, ascending_QMARK_)
        : m__7813__auto__.call(null, coll, ascending_QMARK_);
    else {
      var m__7813__auto____$1 = cljs.core._sorted_seq['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(
              coll,
              ascending_QMARK_
            )
          : m__7813__auto____$1.call(null, coll, ascending_QMARK_);
      else
        throw cljs.core.missing_protocol('ISorted.-sorted-seq', coll);
    }
  }
};
cljs.core._sorted_seq_from = function cljs$core$_sorted_seq_from(
  coll,
  k,
  ascending_QMARK_
) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$ISorted$_sorted_seq_from$arity$3 == null)
  )
    return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(
      coll,
      k,
      ascending_QMARK_
    );
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._sorted_seq_from[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(
            coll,
            k,
            ascending_QMARK_
          )
        : m__7813__auto__.call(null, coll, k, ascending_QMARK_);
    else {
      var m__7813__auto____$1 = cljs.core._sorted_seq_from['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(
              coll,
              k,
              ascending_QMARK_
            )
          : m__7813__auto____$1.call(null, coll, k, ascending_QMARK_);
      else
        throw cljs.core.missing_protocol('ISorted.-sorted-seq-from', coll);
    }
  }
};
cljs.core._entry_key = function cljs$core$_entry_key(coll, entry) {
  if (!(coll == null) && !(coll.cljs$core$ISorted$_entry_key$arity$2 == null))
    return coll.cljs$core$ISorted$_entry_key$arity$2(coll, entry);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._entry_key[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(coll, entry)
        : m__7813__auto__.call(null, coll, entry);
    else {
      var m__7813__auto____$1 = cljs.core._entry_key['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(coll, entry)
          : m__7813__auto____$1.call(null, coll, entry);
      else
        throw cljs.core.missing_protocol('ISorted.-entry-key', coll);
    }
  }
};
cljs.core._comparator = function cljs$core$_comparator(coll) {
  if (!(coll == null) && !(coll.cljs$core$ISorted$_comparator$arity$1 == null))
    return coll.cljs$core$ISorted$_comparator$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._comparator[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._comparator['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('ISorted.-comparator', coll);
    }
  }
};
cljs.core.IWriter = function() {};
cljs.core._write = function cljs$core$_write(writer, s) {
  if (!(writer == null) && !(writer.cljs$core$IWriter$_write$arity$2 == null))
    return writer.cljs$core$IWriter$_write$arity$2(writer, s);
  else {
    var x__7812__auto__ = writer == null ? null : writer;
    var m__7813__auto__ = cljs.core._write[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(writer, s)
        : m__7813__auto__.call(null, writer, s);
    else {
      var m__7813__auto____$1 = cljs.core._write['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(writer, s)
          : m__7813__auto____$1.call(null, writer, s);
      else
        throw cljs.core.missing_protocol('IWriter.-write', writer);
    }
  }
};
cljs.core._flush = function cljs$core$_flush(writer) {
  if (!(writer == null) && !(writer.cljs$core$IWriter$_flush$arity$1 == null))
    return writer.cljs$core$IWriter$_flush$arity$1(writer);
  else {
    var x__7812__auto__ = writer == null ? null : writer;
    var m__7813__auto__ = cljs.core._flush[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(writer)
        : m__7813__auto__.call(null, writer);
    else {
      var m__7813__auto____$1 = cljs.core._flush['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(writer)
          : m__7813__auto____$1.call(null, writer);
      else
        throw cljs.core.missing_protocol('IWriter.-flush', writer);
    }
  }
};
cljs.core.IPrintWithWriter = function() {};
cljs.core._pr_writer = function cljs$core$_pr_writer(o, writer, opts) {
  if (
    !(o == null) && !(o.cljs$core$IPrintWithWriter$_pr_writer$arity$3 == null)
  )
    return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o, writer, opts);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._pr_writer[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(o, writer, opts)
        : m__7813__auto__.call(null, o, writer, opts);
    else {
      var m__7813__auto____$1 = cljs.core._pr_writer['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(o, writer, opts)
          : m__7813__auto____$1.call(null, o, writer, opts);
      else
        throw cljs.core.missing_protocol('IPrintWithWriter.-pr-writer', o);
    }
  }
};
cljs.core.IPending = function() {};
cljs.core._realized_QMARK_ = function cljs$core$_realized_QMARK_(x) {
  if (!(x == null) && !(x.cljs$core$IPending$_realized_QMARK_$arity$1 == null))
    return x.cljs$core$IPending$_realized_QMARK_$arity$1(x);
  else {
    var x__7812__auto__ = x == null ? null : x;
    var m__7813__auto__ = cljs.core._realized_QMARK_[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(x)
        : m__7813__auto__.call(null, x);
    else {
      var m__7813__auto____$1 = cljs.core._realized_QMARK_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(x)
          : m__7813__auto____$1.call(null, x);
      else
        throw cljs.core.missing_protocol('IPending.-realized?', x);
    }
  }
};
cljs.core.IWatchable = function() {};
cljs.core._notify_watches = function cljs$core$_notify_watches(
  this$,
  oldval,
  newval
) {
  if (
    !(this$ == null) &&
    !(this$.cljs$core$IWatchable$_notify_watches$arity$3 == null)
  )
    return this$.cljs$core$IWatchable$_notify_watches$arity$3(
      this$,
      oldval,
      newval
    );
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._notify_watches[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(this$, oldval, newval)
        : m__7813__auto__.call(null, this$, oldval, newval);
    else {
      var m__7813__auto____$1 = cljs.core._notify_watches['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(
              this$,
              oldval,
              newval
            )
          : m__7813__auto____$1.call(null, this$, oldval, newval);
      else
        throw cljs.core.missing_protocol('IWatchable.-notify-watches', this$);
    }
  }
};
cljs.core._add_watch = function cljs$core$_add_watch(this$, key, f) {
  if (
    !(this$ == null) && !(this$.cljs$core$IWatchable$_add_watch$arity$3 == null)
  )
    return this$.cljs$core$IWatchable$_add_watch$arity$3(this$, key, f);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._add_watch[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(this$, key, f)
        : m__7813__auto__.call(null, this$, key, f);
    else {
      var m__7813__auto____$1 = cljs.core._add_watch['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(this$, key, f)
          : m__7813__auto____$1.call(null, this$, key, f);
      else
        throw cljs.core.missing_protocol('IWatchable.-add-watch', this$);
    }
  }
};
cljs.core._remove_watch = function cljs$core$_remove_watch(this$, key) {
  if (
    !(this$ == null) &&
    !(this$.cljs$core$IWatchable$_remove_watch$arity$2 == null)
  )
    return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$, key);
  else {
    var x__7812__auto__ = this$ == null ? null : this$;
    var m__7813__auto__ = cljs.core._remove_watch[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(this$, key)
        : m__7813__auto__.call(null, this$, key);
    else {
      var m__7813__auto____$1 = cljs.core._remove_watch['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(this$, key)
          : m__7813__auto____$1.call(null, this$, key);
      else
        throw cljs.core.missing_protocol('IWatchable.-remove-watch', this$);
    }
  }
};
cljs.core.IEditableCollection = function() {};
cljs.core._as_transient = function cljs$core$_as_transient(coll) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IEditableCollection$_as_transient$arity$1 == null)
  )
    return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._as_transient[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._as_transient['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol(
          'IEditableCollection.-as-transient',
          coll
        );
    }
  }
};
cljs.core.ITransientCollection = function() {};
cljs.core._conj_BANG_ = function cljs$core$_conj_BANG_(tcoll, val) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2 == null)
  )
    return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val);
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._conj_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(tcoll, val)
        : m__7813__auto__.call(null, tcoll, val);
    else {
      var m__7813__auto____$1 = cljs.core._conj_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll, val)
          : m__7813__auto____$1.call(null, tcoll, val);
      else
        throw cljs.core.missing_protocol('ITransientCollection.-conj!', tcoll);
    }
  }
};
cljs.core._persistent_BANG_ = function cljs$core$_persistent_BANG_(tcoll) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 == null)
  )
    return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(
      tcoll
    );
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._persistent_BANG_[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(tcoll)
        : m__7813__auto__.call(null, tcoll);
    else {
      var m__7813__auto____$1 = cljs.core._persistent_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(tcoll)
          : m__7813__auto____$1.call(null, tcoll);
      else
        throw cljs.core.missing_protocol(
          'ITransientCollection.-persistent!',
          tcoll
        );
    }
  }
};
cljs.core.ITransientAssociative = function() {};
cljs.core._assoc_BANG_ = function cljs$core$_assoc_BANG_(tcoll, key, val) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 == null)
  )
    return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(
      tcoll,
      key,
      val
    );
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._assoc_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(tcoll, key, val)
        : m__7813__auto__.call(null, tcoll, key, val);
    else {
      var m__7813__auto____$1 = cljs.core._assoc_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(tcoll, key, val)
          : m__7813__auto____$1.call(null, tcoll, key, val);
      else
        throw cljs.core.missing_protocol(
          'ITransientAssociative.-assoc!',
          tcoll
        );
    }
  }
};
cljs.core.ITransientMap = function() {};
cljs.core._dissoc_BANG_ = function cljs$core$_dissoc_BANG_(tcoll, key) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 == null)
  )
    return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll, key);
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._dissoc_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(tcoll, key)
        : m__7813__auto__.call(null, tcoll, key);
    else {
      var m__7813__auto____$1 = cljs.core._dissoc_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll, key)
          : m__7813__auto____$1.call(null, tcoll, key);
      else
        throw cljs.core.missing_protocol('ITransientMap.-dissoc!', tcoll);
    }
  }
};
cljs.core.ITransientVector = function() {};
cljs.core._assoc_n_BANG_ = function cljs$core$_assoc_n_BANG_(tcoll, n, val) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 == null)
  )
    return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(
      tcoll,
      n,
      val
    );
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._assoc_n_BANG_[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(tcoll, n, val)
        : m__7813__auto__.call(null, tcoll, n, val);
    else {
      var m__7813__auto____$1 = cljs.core._assoc_n_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(tcoll, n, val)
          : m__7813__auto____$1.call(null, tcoll, n, val);
      else
        throw cljs.core.missing_protocol('ITransientVector.-assoc-n!', tcoll);
    }
  }
};
cljs.core._pop_BANG_ = function cljs$core$_pop_BANG_(tcoll) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1 == null)
  )
    return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll);
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._pop_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(tcoll)
        : m__7813__auto__.call(null, tcoll);
    else {
      var m__7813__auto____$1 = cljs.core._pop_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(tcoll)
          : m__7813__auto____$1.call(null, tcoll);
      else
        throw cljs.core.missing_protocol('ITransientVector.-pop!', tcoll);
    }
  }
};
cljs.core.ITransientSet = function() {};
cljs.core._disjoin_BANG_ = function cljs$core$_disjoin_BANG_(tcoll, v) {
  if (
    !(tcoll == null) &&
    !(tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 == null)
  )
    return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll, v);
  else {
    var x__7812__auto__ = tcoll == null ? null : tcoll;
    var m__7813__auto__ = cljs.core._disjoin_BANG_[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(tcoll, v)
        : m__7813__auto__.call(null, tcoll, v);
    else {
      var m__7813__auto____$1 = cljs.core._disjoin_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll, v)
          : m__7813__auto____$1.call(null, tcoll, v);
      else
        throw cljs.core.missing_protocol('ITransientSet.-disjoin!', tcoll);
    }
  }
};
cljs.core.IComparable = function() {};
cljs.core._compare = function cljs$core$_compare(x, y) {
  if (!(x == null) && !(x.cljs$core$IComparable$_compare$arity$2 == null))
    return x.cljs$core$IComparable$_compare$arity$2(x, y);
  else {
    var x__7812__auto__ = x == null ? null : x;
    var m__7813__auto__ = cljs.core._compare[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(x, y)
        : m__7813__auto__.call(null, x, y);
    else {
      var m__7813__auto____$1 = cljs.core._compare['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(x, y)
          : m__7813__auto____$1.call(null, x, y);
      else
        throw cljs.core.missing_protocol('IComparable.-compare', x);
    }
  }
};
cljs.core.IChunk = function() {};
cljs.core._drop_first = function cljs$core$_drop_first(coll) {
  if (!(coll == null) && !(coll.cljs$core$IChunk$_drop_first$arity$1 == null))
    return coll.cljs$core$IChunk$_drop_first$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._drop_first[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._drop_first['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IChunk.-drop-first', coll);
    }
  }
};
cljs.core.IChunkedSeq = function() {};
cljs.core._chunked_first = function cljs$core$_chunked_first(coll) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IChunkedSeq$_chunked_first$arity$1 == null)
  )
    return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._chunked_first[
      goog.typeOf(x__7812__auto__)
    ];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._chunked_first['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IChunkedSeq.-chunked-first', coll);
    }
  }
};
cljs.core._chunked_rest = function cljs$core$_chunked_rest(coll) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1 == null)
  )
    return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._chunked_rest[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._chunked_rest['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IChunkedSeq.-chunked-rest', coll);
    }
  }
};
cljs.core.IChunkedNext = function() {};
cljs.core._chunked_next = function cljs$core$_chunked_next(coll) {
  if (
    !(coll == null) &&
    !(coll.cljs$core$IChunkedNext$_chunked_next$arity$1 == null)
  )
    return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._chunked_next[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._chunked_next['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IChunkedNext.-chunked-next', coll);
    }
  }
};
cljs.core.INamed = function() {};
cljs.core._name = function cljs$core$_name(x) {
  if (!(x == null) && !(x.cljs$core$INamed$_name$arity$1 == null))
    return x.cljs$core$INamed$_name$arity$1(x);
  else {
    var x__7812__auto__ = x == null ? null : x;
    var m__7813__auto__ = cljs.core._name[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(x)
        : m__7813__auto__.call(null, x);
    else {
      var m__7813__auto____$1 = cljs.core._name['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(x)
          : m__7813__auto____$1.call(null, x);
      else
        throw cljs.core.missing_protocol('INamed.-name', x);
    }
  }
};
cljs.core._namespace = function cljs$core$_namespace(x) {
  if (!(x == null) && !(x.cljs$core$INamed$_namespace$arity$1 == null))
    return x.cljs$core$INamed$_namespace$arity$1(x);
  else {
    var x__7812__auto__ = x == null ? null : x;
    var m__7813__auto__ = cljs.core._namespace[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(x)
        : m__7813__auto__.call(null, x);
    else {
      var m__7813__auto____$1 = cljs.core._namespace['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(x)
          : m__7813__auto____$1.call(null, x);
      else
        throw cljs.core.missing_protocol('INamed.-namespace', x);
    }
  }
};
cljs.core.IAtom = function() {};
cljs.core.IReset = function() {};
cljs.core._reset_BANG_ = function cljs$core$_reset_BANG_(o, new_value) {
  if (!(o == null) && !(o.cljs$core$IReset$_reset_BANG_$arity$2 == null))
    return o.cljs$core$IReset$_reset_BANG_$arity$2(o, new_value);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._reset_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, new_value)
        : m__7813__auto__.call(null, o, new_value);
    else {
      var m__7813__auto____$1 = cljs.core._reset_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, new_value)
          : m__7813__auto____$1.call(null, o, new_value);
      else
        throw cljs.core.missing_protocol('IReset.-reset!', o);
    }
  }
};
cljs.core.ISwap = function() {};
cljs.core._swap_BANG_ = function cljs$core$_swap_BANG_(var_args) {
  var args9548 = [];
  var len__8257__auto___9551 = arguments.length;
  var i__8258__auto___9552 = 0;
  while (true) {
    if (i__8258__auto___9552 < len__8257__auto___9551) {
      args9548.push(arguments[i__8258__auto___9552]);
      var G__9553 = i__8258__auto___9552 + 1;
      i__8258__auto___9552 = G__9553;
      continue;
    } else;
    break;
  }
  var G__9550 = args9548.length;
  switch (G__9550) {
    case 2:
      return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9548.length)
        ].join('')
      );
  }
};
cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2 = function(o, f) {
  if (!(o == null) && !(o.cljs$core$ISwap$_swap_BANG_$arity$2 == null))
    return o.cljs$core$ISwap$_swap_BANG_$arity$2(o, f);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, f)
        : m__7813__auto__.call(null, o, f);
    else {
      var m__7813__auto____$1 = cljs.core._swap_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, f)
          : m__7813__auto____$1.call(null, o, f);
      else
        throw cljs.core.missing_protocol('ISwap.-swap!', o);
    }
  }
};
cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3 = function(o, f, a) {
  if (!(o == null) && !(o.cljs$core$ISwap$_swap_BANG_$arity$3 == null))
    return o.cljs$core$ISwap$_swap_BANG_$arity$3(o, f, a);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$3
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$3(o, f, a)
        : m__7813__auto__.call(null, o, f, a);
    else {
      var m__7813__auto____$1 = cljs.core._swap_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$3(o, f, a)
          : m__7813__auto____$1.call(null, o, f, a);
      else
        throw cljs.core.missing_protocol('ISwap.-swap!', o);
    }
  }
};
cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4 = function(o, f, a, b) {
  if (!(o == null) && !(o.cljs$core$ISwap$_swap_BANG_$arity$4 == null))
    return o.cljs$core$ISwap$_swap_BANG_$arity$4(o, f, a, b);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$4
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$4(o, f, a, b)
        : m__7813__auto__.call(null, o, f, a, b);
    else {
      var m__7813__auto____$1 = cljs.core._swap_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$4
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$4(o, f, a, b)
          : m__7813__auto____$1.call(null, o, f, a, b);
      else
        throw cljs.core.missing_protocol('ISwap.-swap!', o);
    }
  }
};
cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5 = function(o, f, a, b, xs) {
  if (!(o == null) && !(o.cljs$core$ISwap$_swap_BANG_$arity$5 == null))
    return o.cljs$core$ISwap$_swap_BANG_$arity$5(o, f, a, b, xs);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$5
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$5(o, f, a, b, xs)
        : m__7813__auto__.call(null, o, f, a, b, xs);
    else {
      var m__7813__auto____$1 = cljs.core._swap_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$5
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$5(o, f, a, b, xs)
          : m__7813__auto____$1.call(null, o, f, a, b, xs);
      else
        throw cljs.core.missing_protocol('ISwap.-swap!', o);
    }
  }
};
cljs.core._swap_BANG_.cljs$lang$maxFixedArity = 5;
cljs.core.IVolatile = function() {};
cljs.core._vreset_BANG_ = function cljs$core$_vreset_BANG_(o, new_value) {
  if (!(o == null) && !(o.cljs$core$IVolatile$_vreset_BANG_$arity$2 == null))
    return o.cljs$core$IVolatile$_vreset_BANG_$arity$2(o, new_value);
  else {
    var x__7812__auto__ = o == null ? null : o;
    var m__7813__auto__ = cljs.core._vreset_BANG_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$2
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$2(o, new_value)
        : m__7813__auto__.call(null, o, new_value);
    else {
      var m__7813__auto____$1 = cljs.core._vreset_BANG_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$2(o, new_value)
          : m__7813__auto____$1.call(null, o, new_value);
      else
        throw cljs.core.missing_protocol('IVolatile.-vreset!', o);
    }
  }
};
cljs.core.IIterable = function() {};
cljs.core._iterator = function cljs$core$_iterator(coll) {
  if (!(coll == null) && !(coll.cljs$core$IIterable$_iterator$arity$1 == null))
    return coll.cljs$core$IIterable$_iterator$arity$1(coll);
  else {
    var x__7812__auto__ = coll == null ? null : coll;
    var m__7813__auto__ = cljs.core._iterator[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(coll)
        : m__7813__auto__.call(null, coll);
    else {
      var m__7813__auto____$1 = cljs.core._iterator['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(coll)
          : m__7813__auto____$1.call(null, coll);
      else
        throw cljs.core.missing_protocol('IIterable.-iterator', coll);
    }
  }
};
cljs.core.StringBufferWriter = function(sb) {
  this.sb = sb;
  this.cljs$lang$protocol_mask$partition0$ = 1073741824;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 = function(
  _,
  s
) {
  var self__ = this;
  var ___$1 = this;
  return self__.sb.append(s);
};
cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 = function(
  _
) {
  var self__ = this;
  var ___$1 = this;
  return null;
};
cljs.core.StringBufferWriter.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    1,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [new cljs.core.Symbol(null, 'sb', 'sb', -1249746442, null)],
    null
  );
};
cljs.core.StringBufferWriter.cljs$lang$type = true;
cljs.core.StringBufferWriter.cljs$lang$ctorStr = 'cljs.core/StringBufferWriter';
cljs.core.StringBufferWriter.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/StringBufferWriter');
};
cljs.core.__GT_StringBufferWriter = function cljs$core$__GT_StringBufferWriter(
  sb
) {
  return new cljs.core.StringBufferWriter(sb);
};
cljs.core.pr_str_STAR_ = function cljs$core$pr_str_STAR_(obj) {
  var sb = new goog.string.StringBuffer();
  var writer = new cljs.core.StringBufferWriter(sb);
  obj.cljs$core$IPrintWithWriter$_pr_writer$arity$3(
    null,
    writer,
    cljs.core.pr_opts()
  );
  writer.cljs$core$IWriter$_flush$arity$1(null);
  return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join('');
};
cljs.core.int_rotate_left = function cljs$core$int_rotate_left(x, n) {
  return x << n | x >>> -n;
};
if (typeof Math.imul !== 'undefined' && !(Math.imul(4294967295, 5) === 0))
  cljs.core.imul = function cljs$core$imul(a, b) {
    return Math.imul(a, b);
  };
else
  cljs.core.imul = function cljs$core$imul(a, b) {
    var ah = a >>> 16 & 65535;
    var al = a & 65535;
    var bh = b >>> 16 & 65535;
    var bl = b & 65535;
    return al * bl + (ah * bl + al * bh << 16 >>> 0) | 0;
  };
cljs.core.m3_seed = 0;
cljs.core.m3_C1 = 3432918353 | 0;
cljs.core.m3_C2 = 461845907 | 0;
cljs.core.m3_mix_K1 = function cljs$core$m3_mix_K1(k1) {
  return cljs.core.imul(
    cljs.core.int_rotate_left(cljs.core.imul(k1 | 0, cljs.core.m3_C1), 15),
    cljs.core.m3_C2
  );
};
cljs.core.m3_mix_H1 = function cljs$core$m3_mix_H1(h1, k1) {
  return cljs.core.imul(cljs.core.int_rotate_left((h1 | 0) ^ (k1 | 0), 13), 5) +
    (3864292196 | 0) |
    0;
};
cljs.core.m3_fmix = function cljs$core$m3_fmix(h1, len) {
  var h1__$1 = h1 | 0;
  var h1__$2 = h1__$1 ^ len;
  var h1__$3 = h1__$2 ^ h1__$2 >>> 16;
  var h1__$4 = cljs.core.imul(h1__$3, 2246822507 | 0);
  var h1__$5 = h1__$4 ^ h1__$4 >>> 13;
  var h1__$6 = cljs.core.imul(h1__$5, 3266489909 | 0);
  return h1__$6 ^ h1__$6 >>> 16;
};
cljs.core.m3_hash_int = function cljs$core$m3_hash_int(in$) {
  if (in$ === 0)
    return in$;
  else {
    var k1 = cljs.core.m3_mix_K1(in$);
    var h1 = cljs.core.m3_mix_H1(cljs.core.m3_seed, k1);
    return cljs.core.m3_fmix(h1, 4);
  }
};
cljs.core.m3_hash_unencoded_chars = function cljs$core$m3_hash_unencoded_chars(
  in$
) {
  var h1 = (function() {
    var i = 1;
    var h1 = cljs.core.m3_seed;
    while (true) {
      if (i < in$.length) {
        var G__9555 = i + 2;
        var G__9556 = cljs.core.m3_mix_H1(
          h1,
          cljs.core.m3_mix_K1(in$.charCodeAt(i - 1) | in$.charCodeAt(i) << 16)
        );
        i = G__9555;
        h1 = G__9556;
        continue;
      } else
        return h1;
      break;
    }
  })();
  var h1__$1 = (in$.length & 1) === 1
    ? h1 ^ cljs.core.m3_mix_K1(in$.charCodeAt(in$.length - 1))
    : h1;
  return cljs.core.m3_fmix(h1__$1, cljs.core.imul(2, in$.length));
};
cljs.core.string_hash_cache = {};
cljs.core.string_hash_cache_count = 0;
cljs.core.hash_string_STAR_ = function cljs$core$hash_string_STAR_(s) {
  if (!(s == null)) {
    var len = s.length;
    if (len > 0) {
      var i = 0;
      var hash = 0;
      while (true) {
        if (i < len) {
          var G__9559 = i + 1;
          var G__9560 = cljs.core.imul(31, hash) + s.charCodeAt(i);
          i = G__9559;
          hash = G__9560;
          continue;
        } else
          return hash;
        break;
      }
    } else
      return 0;
  } else
    return 0;
};
cljs.core.add_to_string_hash_cache = function cljs$core$add_to_string_hash_cache(
  k
) {
  var h = cljs.core.hash_string_STAR_(k);
  cljs.core.string_hash_cache[k] = h;
  cljs.core.string_hash_cache_count = cljs.core.string_hash_cache_count + 1;
  return h;
};
cljs.core.hash_string = function cljs$core$hash_string(k) {
  if (cljs.core.string_hash_cache_count > 255) {
    cljs.core.string_hash_cache = {};
    cljs.core.string_hash_cache_count = 0;
  } else;
  if (k == null)
    return 0;
  else {
    var h = cljs.core.string_hash_cache[k];
    if (typeof h === 'number') return h;
    else return cljs.core.add_to_string_hash_cache(k);
  }
};
cljs.core.hash = function cljs$core$hash(o) {
  if (
    !(o == null)
      ? o.cljs$lang$protocol_mask$partition0$ & 4194304 ||
          cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IHash$
          ? true
          : false
      : false
  )
    return o.cljs$core$IHash$_hash$arity$1(null);
  else if (typeof o === 'number')
    if (cljs.core.truth_(isFinite(o)))
      return Math.floor(o) % 2147483647;
    else {
      var G__9568 = o;
      switch (G__9568) {
        case Infinity:
          return 2146435072;
          break;
        case -Infinity:
          return -1048576;
          break;
        default:
          return 2146959360;
      }
    }
  else if (o === true) return 1231;
  else if (o === false) return 1237;
  else if (typeof o === 'string')
    return cljs.core.m3_hash_int(cljs.core.hash_string(o));
  else if (o instanceof Date) return o.valueOf();
  else if (o == null) return 0;
  else return cljs.core._hash(o);
};
cljs.core.hash_combine = function cljs$core$hash_combine(seed, hash) {
  return seed ^ hash + 2654435769 + (seed << 6) + (seed >> 2);
};
cljs.core.instance_QMARK_ = function cljs$core$instance_QMARK_(c, x) {
  return x instanceof c;
};
cljs.core.symbol_QMARK_ = function cljs$core$symbol_QMARK_(x) {
  return x instanceof cljs.core.Symbol;
};
cljs.core.hash_symbol = function cljs$core$hash_symbol(sym) {
  return cljs.core.hash_combine(
    cljs.core.m3_hash_unencoded_chars(sym.name),
    cljs.core.hash_string(sym.ns)
  );
};
cljs.core.compare_symbols = function cljs$core$compare_symbols(a, b) {
  if (a.str === b.str)
    return 0;
  else if (
    cljs.core.truth_(
      (function() {
        var and__7132__auto__ = cljs.core.not(a.ns);
        if (and__7132__auto__) return b.ns;
        else return and__7132__auto__;
      })()
    )
  )
    return -1;
  else if (cljs.core.truth_(a.ns))
    if (cljs.core.not(b.ns))
      return 1;
    else {
      var nsc = (function() {
        var G__9576 = a.ns;
        var G__9577 = b.ns;
        return goog.array.defaultCompare(G__9576, G__9577);
      })();
      if (0 === nsc) {
        var G__9578 = a.name;
        var G__9579 = b.name;
        return goog.array.defaultCompare(G__9578, G__9579);
      } else
        return nsc;
    }
  else {
    var G__9580 = a.name;
    var G__9581 = b.name;
    return goog.array.defaultCompare(G__9580, G__9581);
  }
};
cljs.core.Symbol = function(ns, name, str, _hash, _meta) {
  this.ns = ns;
  this.name = name;
  this.str = str;
  this._hash = _hash;
  this._meta = _meta;
  this.cljs$lang$protocol_mask$partition0$ = 2154168321;
  this.cljs$lang$protocol_mask$partition1$ = 4096;
};
cljs.core.Symbol.prototype.toString = function() {
  var self__ = this;
  var _ = this;
  return self__.str;
};
cljs.core.Symbol.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  _,
  other
) {
  var self__ = this;
  var ___$1 = this;
  if (other instanceof cljs.core.Symbol) return self__.str === other.str;
  else return false;
};
cljs.core.Symbol.prototype.call = (function() {
  var G__9583 = null;
  var G__9583__2 = function(self__, coll) {
    var self__ = this;
    var self____$1 = this;
    var sym = self____$1;
    return cljs.core.get.cljs$core$IFn$_invoke$arity$2
      ? cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll, sym)
      : cljs.core.get.call(null, coll, sym);
  };
  var G__9583__3 = function(self__, coll, not_found) {
    var self__ = this;
    var self____$1 = this;
    var sym = self____$1;
    return cljs.core.get.cljs$core$IFn$_invoke$arity$3
      ? cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll, sym, not_found)
      : cljs.core.get.call(null, coll, sym, not_found);
  };
  G__9583 = function(self__, coll, not_found) {
    switch (arguments.length) {
      case 2:
        return G__9583__2.call(this, self__, coll);
      case 3:
        return G__9583__3.call(this, self__, coll, not_found);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9583.cljs$core$IFn$_invoke$arity$2 = G__9583__2;
  G__9583.cljs$core$IFn$_invoke$arity$3 = G__9583__3;
  return G__9583;
})();
cljs.core.Symbol.prototype.apply = function(self__, args9582) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args9582))
  );
};
cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  var self__ = this;
  var sym = this;
  return cljs.core.get.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll, sym)
    : cljs.core.get.call(null, coll, sym);
};
cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$2 = function(
  coll,
  not_found
) {
  var self__ = this;
  var sym = this;
  return cljs.core.get.cljs$core$IFn$_invoke$arity$3
    ? cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll, sym, not_found)
    : cljs.core.get.call(null, coll, sym, not_found);
};
cljs.core.Symbol.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__._meta;
};
cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  _,
  new_meta
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.Symbol(
    self__.ns,
    self__.name,
    self__.str,
    self__._hash,
    new_meta
  );
};
cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 = function(sym) {
  var self__ = this;
  var sym__$1 = this;
  var h__7584__auto__ = self__._hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_symbol(sym__$1);
    self__._hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.name;
};
cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.ns;
};
cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(
  o,
  writer,
  _
) {
  var self__ = this;
  var o__$1 = this;
  return cljs.core._write(writer, self__.str);
};
cljs.core.Symbol.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    5,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'ns', 'ns', 2082130287, null),
      new cljs.core.Symbol(null, 'name', 'name', -810760592, null),
      new cljs.core.Symbol(null, 'str', 'str', -1564826950, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '_hash', '_hash', -2130838312, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      new cljs.core.Symbol(null, '_meta', '_meta', -1716892533, null)
    ],
    null
  );
};
cljs.core.Symbol.cljs$lang$type = true;
cljs.core.Symbol.cljs$lang$ctorStr = 'cljs.core/Symbol';
cljs.core.Symbol.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Symbol');
};
cljs.core.__GT_Symbol = function cljs$core$__GT_Symbol(
  ns,
  name,
  str,
  _hash,
  _meta
) {
  return new cljs.core.Symbol(ns, name, str, _hash, _meta);
};
cljs.core.symbol = function cljs$core$symbol(var_args) {
  var args9584 = [];
  var len__8257__auto___9587 = arguments.length;
  var i__8258__auto___9588 = 0;
  while (true) {
    if (i__8258__auto___9588 < len__8257__auto___9587) {
      args9584.push(arguments[i__8258__auto___9588]);
      var G__9589 = i__8258__auto___9588 + 1;
      i__8258__auto___9588 = G__9589;
      continue;
    } else;
    break;
  }
  var G__9586 = args9584.length;
  switch (G__9586) {
    case 1:
      return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9584.length)
        ].join('')
      );
  }
};
cljs.core.symbol.cljs$core$IFn$_invoke$arity$1 = function(name) {
  if (name instanceof cljs.core.Symbol)
    return name;
  else {
    var idx = name.indexOf('/');
    if (idx < 1)
      return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(null, name);
    else
      return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(
        name.substring(0, idx),
        name.substring(idx + 1, name.length)
      );
  }
};
cljs.core.symbol.cljs$core$IFn$_invoke$arity$2 = function(ns, name) {
  var sym_str = !(ns == null)
    ? [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1('/'),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)
      ].join('')
    : name;
  return new cljs.core.Symbol(ns, name, sym_str, null, null);
};
cljs.core.symbol.cljs$lang$maxFixedArity = 2;
cljs.core.Var = function(val, sym, _meta) {
  this.val = val;
  this.sym = sym;
  this._meta = _meta;
  this.cljs$lang$protocol_mask$partition0$ = 6717441;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.Var.prototype.isMacro = function() {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).cljs$lang$macro;
};
cljs.core.Var.prototype.toString = function() {
  var self__ = this;
  var _ = this;
  return [
    cljs.core.str.cljs$core$IFn$_invoke$arity$1("#'"),
    cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.sym)
  ].join('');
};
cljs.core.Var.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null);
};
cljs.core.Var.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__._meta;
};
cljs.core.Var.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  _,
  new_meta
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.Var(self__.val, self__.sym, new_meta);
};
cljs.core.Var.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  this$,
  other
) {
  var self__ = this;
  var this$__$1 = this;
  if (other instanceof cljs.core.Var) {
    var G__9592 = this$__$1.sym;
    var G__9593 = other.sym;
    return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2
      ? cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(G__9592, G__9593)
      : cljs.core._EQ_.call(null, G__9592, G__9593);
  } else
    return false;
};
cljs.core.Var.prototype.cljs$core$IHash$_hash$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return cljs.core.hash_symbol(self__.sym);
};
cljs.core.Var.prototype.cljs$core$Fn$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.Var.prototype.call = (function() {
  var G__9638 = null;
  var G__9638__1 = function(self__) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null);
  };
  var G__9638__2 = function(self__, a) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a);
  };
  var G__9638__3 = function(self__, a, b) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b);
  };
  var G__9638__4 = function(self__, a, b, c) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c);
  };
  var G__9638__5 = function(self__, a, b, c, d) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d);
  };
  var G__9638__6 = function(self__, a, b, c, d, e) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e);
  };
  var G__9638__7 = function(self__, a, b, c, d, e, f) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f);
  };
  var G__9638__8 = function(self__, a, b, c, d, e, f, g) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g);
  };
  var G__9638__9 = function(self__, a, b, c, d, e, f, g, h) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h);
  };
  var G__9638__10 = function(self__, a, b, c, d, e, f, g, h, i) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i);
  };
  var G__9638__11 = function(self__, a, b, c, d, e, f, g, h, i, j) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j);
  };
  var G__9638__12 = function(self__, a, b, c, d, e, f, g, h, i, j, k) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j, k);
  };
  var G__9638__13 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j, k, l);
  };
  var G__9638__14 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l, m) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m
    );
  };
  var G__9638__15 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l, m, n) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n
    );
  };
  var G__9638__16 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o
    );
  };
  var G__9638__17 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p
    );
  };
  var G__9638__18 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q
    );
  };
  var G__9638__19 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r
    );
  };
  var G__9638__20 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r,
      s
    );
  };
  var G__9638__21 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return (self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null)).call(
      null,
      a,
      b,
      c,
      d,
      e,
      f,
      g,
      h,
      i,
      j,
      k,
      l,
      m,
      n,
      o,
      p,
      q,
      r,
      s,
      t
    );
  };
  var G__9638__22 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    rest
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    var G__9594 = self__.val.cljs$core$IFn$_invoke$arity$0
      ? self__.val.cljs$core$IFn$_invoke$arity$0()
      : self__.val.call(null);
    var G__9595 = a;
    var G__9596 = b;
    var G__9597 = c;
    var G__9598 = d;
    var G__9599 = e;
    var G__9600 = f;
    var G__9601 = g;
    var G__9602 = h;
    var G__9603 = i;
    var G__9604 = j;
    var G__9605 = k;
    var G__9606 = l;
    var G__9607 = m;
    var G__9608 = n;
    var G__9609 = o;
    var G__9610 = p;
    var G__9611 = q;
    var G__9612 = r;
    var G__9613 = s;
    var G__9614 = t;
    var G__9615 = rest;
    return cljs.core.apply.cljs$core$IFn$_invoke$arity$22
      ? cljs.core.apply.cljs$core$IFn$_invoke$arity$22(
          G__9594,
          G__9595,
          G__9596,
          G__9597,
          G__9598,
          G__9599,
          G__9600,
          G__9601,
          G__9602,
          G__9603,
          G__9604,
          G__9605,
          G__9606,
          G__9607,
          G__9608,
          G__9609,
          G__9610,
          G__9611,
          G__9612,
          G__9613,
          G__9614,
          G__9615
        )
      : cljs.core.apply.call(
          null,
          G__9594,
          G__9595,
          G__9596,
          G__9597,
          G__9598,
          G__9599,
          G__9600,
          G__9601,
          G__9602,
          G__9603,
          G__9604,
          G__9605,
          G__9606,
          G__9607,
          G__9608,
          G__9609,
          G__9610,
          G__9611,
          G__9612,
          G__9613,
          G__9614,
          G__9615
        );
  };
  G__9638 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    rest
  ) {
    switch (arguments.length) {
      case 1:
        return G__9638__1.call(this, self__);
      case 2:
        return G__9638__2.call(this, self__, a);
      case 3:
        return G__9638__3.call(this, self__, a, b);
      case 4:
        return G__9638__4.call(this, self__, a, b, c);
      case 5:
        return G__9638__5.call(this, self__, a, b, c, d);
      case 6:
        return G__9638__6.call(this, self__, a, b, c, d, e);
      case 7:
        return G__9638__7.call(this, self__, a, b, c, d, e, f);
      case 8:
        return G__9638__8.call(this, self__, a, b, c, d, e, f, g);
      case 9:
        return G__9638__9.call(this, self__, a, b, c, d, e, f, g, h);
      case 10:
        return G__9638__10.call(this, self__, a, b, c, d, e, f, g, h, i);
      case 11:
        return G__9638__11.call(this, self__, a, b, c, d, e, f, g, h, i, j);
      case 12:
        return G__9638__12.call(this, self__, a, b, c, d, e, f, g, h, i, j, k);
      case 13:
        return G__9638__13.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l
        );
      case 14:
        return G__9638__14.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m
        );
      case 15:
        return G__9638__15.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n
        );
      case 16:
        return G__9638__16.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o
        );
      case 17:
        return G__9638__17.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p
        );
      case 18:
        return G__9638__18.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q
        );
      case 19:
        return G__9638__19.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r
        );
      case 20:
        return G__9638__20.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s
        );
      case 21:
        return G__9638__21.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t
        );
      case 22:
        return G__9638__22.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t,
          rest
        );
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9638.cljs$core$IFn$_invoke$arity$1 = G__9638__1;
  G__9638.cljs$core$IFn$_invoke$arity$2 = G__9638__2;
  G__9638.cljs$core$IFn$_invoke$arity$3 = G__9638__3;
  G__9638.cljs$core$IFn$_invoke$arity$4 = G__9638__4;
  G__9638.cljs$core$IFn$_invoke$arity$5 = G__9638__5;
  G__9638.cljs$core$IFn$_invoke$arity$6 = G__9638__6;
  G__9638.cljs$core$IFn$_invoke$arity$7 = G__9638__7;
  G__9638.cljs$core$IFn$_invoke$arity$8 = G__9638__8;
  G__9638.cljs$core$IFn$_invoke$arity$9 = G__9638__9;
  G__9638.cljs$core$IFn$_invoke$arity$10 = G__9638__10;
  G__9638.cljs$core$IFn$_invoke$arity$11 = G__9638__11;
  G__9638.cljs$core$IFn$_invoke$arity$12 = G__9638__12;
  G__9638.cljs$core$IFn$_invoke$arity$13 = G__9638__13;
  G__9638.cljs$core$IFn$_invoke$arity$14 = G__9638__14;
  G__9638.cljs$core$IFn$_invoke$arity$15 = G__9638__15;
  G__9638.cljs$core$IFn$_invoke$arity$16 = G__9638__16;
  G__9638.cljs$core$IFn$_invoke$arity$17 = G__9638__17;
  G__9638.cljs$core$IFn$_invoke$arity$18 = G__9638__18;
  G__9638.cljs$core$IFn$_invoke$arity$19 = G__9638__19;
  G__9638.cljs$core$IFn$_invoke$arity$20 = G__9638__20;
  G__9638.cljs$core$IFn$_invoke$arity$21 = G__9638__21;
  G__9638.cljs$core$IFn$_invoke$arity$22 = G__9638__22;
  return G__9638;
})();
cljs.core.Var.prototype.apply = function(self__, args9591) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args9591))
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$0 = function() {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$1 = function(a) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$2 = function(a, b) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$3 = function(a, b, c) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$4 = function(a, b, c, d) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$5 = function(
  a,
  b,
  c,
  d,
  e
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$6 = function(
  a,
  b,
  c,
  d,
  e,
  f
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$7 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$8 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$9 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$10 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$11 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j, k);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$12 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j, k, l);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$13 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(null, a, b, c, d, e, f, g, h, i, j, k, l, m);
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$14 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$15 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$16 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$17 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$18 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$19 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$20 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t
) {
  var self__ = this;
  var _ = this;
  return (self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null)).call(
    null,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t
  );
};
cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$21 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t,
  rest
) {
  var self__ = this;
  var _ = this;
  var G__9616 = self__.val.cljs$core$IFn$_invoke$arity$0
    ? self__.val.cljs$core$IFn$_invoke$arity$0()
    : self__.val.call(null);
  var G__9617 = a;
  var G__9618 = b;
  var G__9619 = c;
  var G__9620 = d;
  var G__9621 = e;
  var G__9622 = f;
  var G__9623 = g;
  var G__9624 = h;
  var G__9625 = i;
  var G__9626 = j;
  var G__9627 = k;
  var G__9628 = l;
  var G__9629 = m;
  var G__9630 = n;
  var G__9631 = o;
  var G__9632 = p;
  var G__9633 = q;
  var G__9634 = r;
  var G__9635 = s;
  var G__9636 = t;
  var G__9637 = rest;
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$22
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$22(
        G__9616,
        G__9617,
        G__9618,
        G__9619,
        G__9620,
        G__9621,
        G__9622,
        G__9623,
        G__9624,
        G__9625,
        G__9626,
        G__9627,
        G__9628,
        G__9629,
        G__9630,
        G__9631,
        G__9632,
        G__9633,
        G__9634,
        G__9635,
        G__9636,
        G__9637
      )
    : cljs.core.apply.call(
        null,
        G__9616,
        G__9617,
        G__9618,
        G__9619,
        G__9620,
        G__9621,
        G__9622,
        G__9623,
        G__9624,
        G__9625,
        G__9626,
        G__9627,
        G__9628,
        G__9629,
        G__9630,
        G__9631,
        G__9632,
        G__9633,
        G__9634,
        G__9635,
        G__9636,
        G__9637
      );
};
cljs.core.Var.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'val', 'val', 1769233139, null),
      new cljs.core.Symbol(null, 'sym', 'sym', 195671222, null),
      new cljs.core.Symbol(null, '_meta', '_meta', -1716892533, null)
    ],
    null
  );
};
cljs.core.Var.cljs$lang$type = true;
cljs.core.Var.cljs$lang$ctorStr = 'cljs.core/Var';
cljs.core.Var.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Var');
};
cljs.core.__GT_Var = function cljs$core$__GT_Var(val, sym, _meta) {
  return new cljs.core.Var(val, sym, _meta);
};
cljs.core.var_QMARK_ = function cljs$core$var_QMARK_(v) {
  return v instanceof cljs.core.Var;
};
cljs.core.iterable_QMARK_ = function cljs$core$iterable_QMARK_(x) {
  if (!(x == null))
    if (false || cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IIterable$)
      return true;
    else if (!x.cljs$lang$protocol_mask$partition$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IIterable, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IIterable, x);
};
cljs.core.clone = function cljs$core$clone(value) {
  return cljs.core._clone(value);
};
cljs.core.cloneable_QMARK_ = function cljs$core$cloneable_QMARK_(value) {
  if (!(value == null))
    if (
      value.cljs$lang$protocol_mask$partition1$ & 8192 ||
      cljs.core.PROTOCOL_SENTINEL === value.cljs$core$ICloneable$
    )
      return true;
    else if (!value.cljs$lang$protocol_mask$partition1$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable, value);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable, value);
};
cljs.core.seq = function cljs$core$seq(coll) {
  if (coll == null) return null;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 8388608 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeqable$
          ? true
          : false
      : false
  )
    return coll.cljs$core$ISeqable$_seq$arity$1(null);
  else if (cljs.core.array_QMARK_(coll)) if (coll.length === 0) return null;
    else return new cljs.core.IndexedSeq(coll, 0, null);
  else if (typeof coll === 'string') if (coll.length === 0) return null;
    else return new cljs.core.IndexedSeq(coll, 0, null);
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable, coll))
    return cljs.core._seq(coll);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(' is not ISeqable')
      ].join('')
    );
};
cljs.core.first = function cljs$core$first(coll) {
  if (coll == null)
    return null;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 64 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$
          ? true
          : false
      : false
  )
    return coll.cljs$core$ISeq$_first$arity$1(null);
  else {
    var s = cljs.core.seq(coll);
    if (s == null) return null;
    else return cljs.core._first(s);
  }
};
cljs.core.rest = function cljs$core$rest(coll) {
  if (!(coll == null))
    if (
      !(coll == null)
        ? coll.cljs$lang$protocol_mask$partition0$ & 64 ||
            cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$
            ? true
            : false
        : false
    )
      return coll.cljs$core$ISeq$_rest$arity$1(null);
    else {
      var s = cljs.core.seq(coll);
      if (s) return cljs.core._rest(s);
      else return cljs.core.List.EMPTY;
    }
  else
    return cljs.core.List.EMPTY;
};
cljs.core.next = function cljs$core$next(coll) {
  if (coll == null) return null;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 128 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$INext$
          ? true
          : false
      : false
  )
    return coll.cljs$core$INext$_next$arity$1(null);
  else
    return cljs.core.seq(cljs.core.rest(coll));
};
cljs.core._EQ_ = function cljs$core$_EQ_(var_args) {
  var args9651 = [];
  var len__8257__auto___9657 = arguments.length;
  var i__8258__auto___9658 = 0;
  while (true) {
    if (i__8258__auto___9658 < len__8257__auto___9657) {
      args9651.push(arguments[i__8258__auto___9658]);
      var G__9659 = i__8258__auto___9658 + 1;
      i__8258__auto___9658 = G__9659;
      continue;
    } else;
    break;
  }
  var G__9656 = args9651.length;
  switch (G__9656) {
    case 1:
      return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9651.slice(2),
        0,
        null
      );
      return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  if (x == null) return y == null;
  else return x === y || cljs.core._equiv(x, y);
};
cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x, y))
      if (cljs.core.next(more)) {
        var G__9661 = y;
        var G__9662 = cljs.core.first(more);
        var G__9663 = cljs.core.next(more);
        x = G__9661;
        y = G__9662;
        more = G__9663;
        continue;
      } else
        return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
          y,
          cljs.core.first(more)
        );
    else
      return false;
    break;
  }
};
cljs.core._EQ_.cljs$lang$applyTo = function(seq9652) {
  var G__9653 = cljs.core.first(seq9652);
  var seq9652__$1 = cljs.core.next(seq9652);
  var G__9654 = cljs.core.first(seq9652__$1);
  var seq9652__$2 = cljs.core.next(seq9652__$1);
  return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic(
    G__9653,
    G__9654,
    seq9652__$2
  );
};
cljs.core._EQ_.cljs$lang$maxFixedArity = 2;
cljs.core.ES6Iterator = function(s) {
  this.s = s;
};
cljs.core.ES6Iterator.prototype.next = function() {
  var self__ = this;
  var _ = this;
  if (!(self__.s == null)) {
    var x = cljs.core.first(self__.s);
    self__.s = cljs.core.next(self__.s);
    return { value: x, done: false };
  } else
    return { value: null, done: true };
};
cljs.core.ES6Iterator.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    1,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 's', 's', -948495851, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ES6Iterator.cljs$lang$type = true;
cljs.core.ES6Iterator.cljs$lang$ctorStr = 'cljs.core/ES6Iterator';
cljs.core.ES6Iterator.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ES6Iterator');
};
cljs.core.__GT_ES6Iterator = function cljs$core$__GT_ES6Iterator(s) {
  return new cljs.core.ES6Iterator(s);
};
cljs.core.es6_iterator = function cljs$core$es6_iterator(coll) {
  return new cljs.core.ES6Iterator(cljs.core.seq(coll));
};
cljs.core.ES6IteratorSeq = function(value, iter, _rest) {
  this.value = value;
  this.iter = iter;
  this._rest = _rest;
  this.cljs$lang$protocol_mask$partition0$ = 8388672;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  return this$__$1;
};
cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.value;
};
cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  if (self__._rest == null)
    self__._rest = cljs.core.es6_iterator_seq.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.es6_iterator_seq.cljs$core$IFn$_invoke$arity$1(self__.iter)
      : cljs.core.es6_iterator_seq.call(null, self__.iter);
  else;
  return self__._rest;
};
cljs.core.ES6IteratorSeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'value', 'value', 1946509744, null),
      new cljs.core.Symbol(null, 'iter', 'iter', -1346195486, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '_rest', '_rest', -2100466189, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ES6IteratorSeq.cljs$lang$type = true;
cljs.core.ES6IteratorSeq.cljs$lang$ctorStr = 'cljs.core/ES6IteratorSeq';
cljs.core.ES6IteratorSeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ES6IteratorSeq');
};
cljs.core.__GT_ES6IteratorSeq = function cljs$core$__GT_ES6IteratorSeq(
  value,
  iter,
  _rest
) {
  return new cljs.core.ES6IteratorSeq(value, iter, _rest);
};
cljs.core.es6_iterator_seq = function cljs$core$es6_iterator_seq(iter) {
  var v = iter.next();
  if (cljs.core.truth_(v.done)) return cljs.core.List.EMPTY;
  else return new cljs.core.ES6IteratorSeq(v.value, iter, null);
};
cljs.core.mix_collection_hash = function cljs$core$mix_collection_hash(
  hash_basis,
  count
) {
  var h1 = cljs.core.m3_seed;
  var k1 = cljs.core.m3_mix_K1(hash_basis);
  var h1__$1 = cljs.core.m3_mix_H1(h1, k1);
  return cljs.core.m3_fmix(h1__$1, count);
};
cljs.core.hash_ordered_coll = function cljs$core$hash_ordered_coll(coll) {
  var n = 0;
  var hash_code = 1;
  var coll__$1 = cljs.core.seq(coll);
  while (true) {
    if (!(coll__$1 == null)) {
      var G__9664 = n + 1;
      var G__9665 = cljs.core.imul(31, hash_code) +
        cljs.core.hash(cljs.core.first(coll__$1)) |
        0;
      var G__9666 = cljs.core.next(coll__$1);
      n = G__9664;
      hash_code = G__9665;
      coll__$1 = G__9666;
      continue;
    } else
      return cljs.core.mix_collection_hash(hash_code, n);
    break;
  }
};
cljs.core.empty_ordered_hash = cljs.core.mix_collection_hash(1, 0);
cljs.core.hash_unordered_coll = function cljs$core$hash_unordered_coll(coll) {
  var n = 0;
  var hash_code = 0;
  var coll__$1 = cljs.core.seq(coll);
  while (true) {
    if (!(coll__$1 == null)) {
      var G__9667 = n + 1;
      var G__9668 = hash_code + cljs.core.hash(cljs.core.first(coll__$1)) | 0;
      var G__9669 = cljs.core.next(coll__$1);
      n = G__9667;
      hash_code = G__9668;
      coll__$1 = G__9669;
      continue;
    } else
      return cljs.core.mix_collection_hash(hash_code, n);
    break;
  }
};
cljs.core.empty_unordered_hash = cljs.core.mix_collection_hash(0, 0);
cljs.core.ICounted['null'] = true;
cljs.core._count['null'] = function(_) {
  return 0;
};
Date.prototype.cljs$core$IEquiv$ = cljs.core.PROTOCOL_SENTINEL;
Date.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
  var o__$1 = this;
  return other instanceof Date && o__$1.valueOf() === other.valueOf();
};
Date.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL;
Date.prototype.cljs$core$IComparable$_compare$arity$2 = function(this$, other) {
  var this$__$1 = this;
  if (other instanceof Date) {
    var G__9670 = this$__$1.valueOf();
    var G__9671 = other.valueOf();
    return goog.array.defaultCompare(G__9670, G__9671);
  } else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1('Cannot compare '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(' to '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)
      ].join('')
    );
};
cljs.core.Inst = function() {};
cljs.core.inst_ms_STAR_ = function cljs$core$inst_ms_STAR_(inst) {
  if (!(inst == null) && !(inst.cljs$core$Inst$inst_ms_STAR_$arity$1 == null))
    return inst.cljs$core$Inst$inst_ms_STAR_$arity$1(inst);
  else {
    var x__7812__auto__ = inst == null ? null : inst;
    var m__7813__auto__ = cljs.core.inst_ms_STAR_[goog.typeOf(x__7812__auto__)];
    if (!(m__7813__auto__ == null))
      return m__7813__auto__.cljs$core$IFn$_invoke$arity$1
        ? m__7813__auto__.cljs$core$IFn$_invoke$arity$1(inst)
        : m__7813__auto__.call(null, inst);
    else {
      var m__7813__auto____$1 = cljs.core.inst_ms_STAR_['_'];
      if (!(m__7813__auto____$1 == null))
        return m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1
          ? m__7813__auto____$1.cljs$core$IFn$_invoke$arity$1(inst)
          : m__7813__auto____$1.call(null, inst);
      else
        throw cljs.core.missing_protocol('Inst.inst-ms*', inst);
    }
  }
};
Date.prototype.cljs$core$Inst$ = cljs.core.PROTOCOL_SENTINEL;
Date.prototype.cljs$core$Inst$inst_ms_STAR_$arity$1 = function(inst) {
  var inst__$1 = this;
  return inst__$1.getTime();
};
cljs.core.inst_ms = function cljs$core$inst_ms(inst) {
  return cljs.core.inst_ms_STAR_(inst);
};
cljs.core.inst_QMARK_ = function cljs$core$inst_QMARK_(x) {
  if (!(x == null))
    if (false || cljs.core.PROTOCOL_SENTINEL === x.cljs$core$Inst$) return true;
    else if (!x.cljs$lang$protocol_mask$partition$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.Inst, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.Inst, x);
};
cljs.core.IEquiv['number'] = true;
cljs.core._equiv['number'] = function(x, o) {
  return x === o;
};
cljs.core.Fn['function'] = true;
cljs.core.IMeta['function'] = true;
cljs.core._meta['function'] = function(_) {
  return null;
};
cljs.core.IHash['_'] = true;
cljs.core._hash['_'] = function(o) {
  return goog.getUid(o);
};
cljs.core.inc = function cljs$core$inc(x) {
  return x + 1;
};
cljs.core.Reduced = function(val) {
  this.val = val;
  this.cljs$lang$protocol_mask$partition0$ = 32768;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 = function(o) {
  var self__ = this;
  var o__$1 = this;
  return self__.val;
};
cljs.core.Reduced.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    1,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [new cljs.core.Symbol(null, 'val', 'val', 1769233139, null)],
    null
  );
};
cljs.core.Reduced.cljs$lang$type = true;
cljs.core.Reduced.cljs$lang$ctorStr = 'cljs.core/Reduced';
cljs.core.Reduced.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Reduced');
};
cljs.core.__GT_Reduced = function cljs$core$__GT_Reduced(val) {
  return new cljs.core.Reduced(val);
};
cljs.core.reduced = function cljs$core$reduced(x) {
  return new cljs.core.Reduced(x);
};
cljs.core.reduced_QMARK_ = function cljs$core$reduced_QMARK_(r) {
  return r instanceof cljs.core.Reduced;
};
cljs.core.ensure_reduced = function cljs$core$ensure_reduced(x) {
  if (cljs.core.reduced_QMARK_(x)) return x;
  else return cljs.core.reduced(x);
};
cljs.core.unreduced = function cljs$core$unreduced(x) {
  if (cljs.core.reduced_QMARK_(x))
    return cljs.core.deref.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.deref.cljs$core$IFn$_invoke$arity$1(x)
      : cljs.core.deref.call(null, x);
  else
    return x;
};
cljs.core.deref = function cljs$core$deref(o) {
  return cljs.core._deref(o);
};
cljs.core.ci_reduce = function cljs$core$ci_reduce(var_args) {
  var args9674 = [];
  var len__8257__auto___9683 = arguments.length;
  var i__8258__auto___9684 = 0;
  while (true) {
    if (i__8258__auto___9684 < len__8257__auto___9683) {
      args9674.push(arguments[i__8258__auto___9684]);
      var G__9685 = i__8258__auto___9684 + 1;
      i__8258__auto___9684 = G__9685;
      continue;
    } else;
    break;
  }
  var G__9676 = args9674.length;
  switch (G__9676) {
    case 2:
      return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9674.length)
        ].join('')
      );
  }
};
cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2 = function(cicoll, f) {
  var cnt = cljs.core._count(cicoll);
  if (cnt === 0)
    return f.cljs$core$IFn$_invoke$arity$0
      ? f.cljs$core$IFn$_invoke$arity$0()
      : f.call(null);
  else {
    var val = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll, 0);
    var n = 1;
    while (true) {
      if (n < cnt) {
        var nval = (function() {
          var G__9677 = val;
          var G__9678 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll, n);
          return f.cljs$core$IFn$_invoke$arity$2
            ? f.cljs$core$IFn$_invoke$arity$2(G__9677, G__9678)
            : f.call(null, G__9677, G__9678);
        })();
        if (cljs.core.reduced_QMARK_(nval))
          return cljs.core.deref(nval);
        else {
          var G__9687 = nval;
          var G__9688 = n + 1;
          val = G__9687;
          n = G__9688;
          continue;
        }
      } else
        return val;
      break;
    }
  }
};
cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3 = function(cicoll, f, val) {
  var cnt = cljs.core._count(cicoll);
  var val__$1 = val;
  var n = 0;
  while (true) {
    if (n < cnt) {
      var nval = (function() {
        var G__9679 = val__$1;
        var G__9680 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll, n);
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__9679, G__9680)
          : f.call(null, G__9679, G__9680);
      })();
      if (cljs.core.reduced_QMARK_(nval))
        return cljs.core.deref(nval);
      else {
        var G__9689 = nval;
        var G__9690 = n + 1;
        val__$1 = G__9689;
        n = G__9690;
        continue;
      }
    } else
      return val__$1;
    break;
  }
};
cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$4 = function(
  cicoll,
  f,
  val,
  idx
) {
  var cnt = cljs.core._count(cicoll);
  var val__$1 = val;
  var n = idx;
  while (true) {
    if (n < cnt) {
      var nval = (function() {
        var G__9681 = val__$1;
        var G__9682 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll, n);
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__9681, G__9682)
          : f.call(null, G__9681, G__9682);
      })();
      if (cljs.core.reduced_QMARK_(nval))
        return cljs.core.deref(nval);
      else {
        var G__9691 = nval;
        var G__9692 = n + 1;
        val__$1 = G__9691;
        n = G__9692;
        continue;
      }
    } else
      return val__$1;
    break;
  }
};
cljs.core.ci_reduce.cljs$lang$maxFixedArity = 4;
cljs.core.array_reduce = function cljs$core$array_reduce(var_args) {
  var args9693 = [];
  var len__8257__auto___9702 = arguments.length;
  var i__8258__auto___9703 = 0;
  while (true) {
    if (i__8258__auto___9703 < len__8257__auto___9702) {
      args9693.push(arguments[i__8258__auto___9703]);
      var G__9704 = i__8258__auto___9703 + 1;
      i__8258__auto___9703 = G__9704;
      continue;
    } else;
    break;
  }
  var G__9695 = args9693.length;
  switch (G__9695) {
    case 2:
      return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9693.length)
        ].join('')
      );
  }
};
cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2 = function(arr, f) {
  var cnt = arr.length;
  if (arr.length === 0)
    return f.cljs$core$IFn$_invoke$arity$0
      ? f.cljs$core$IFn$_invoke$arity$0()
      : f.call(null);
  else {
    var val = arr[0];
    var n = 1;
    while (true) {
      if (n < cnt) {
        var nval = (function() {
          var G__9696 = val;
          var G__9697 = arr[n];
          return f.cljs$core$IFn$_invoke$arity$2
            ? f.cljs$core$IFn$_invoke$arity$2(G__9696, G__9697)
            : f.call(null, G__9696, G__9697);
        })();
        if (cljs.core.reduced_QMARK_(nval))
          return cljs.core.deref(nval);
        else {
          var G__9706 = nval;
          var G__9707 = n + 1;
          val = G__9706;
          n = G__9707;
          continue;
        }
      } else
        return val;
      break;
    }
  }
};
cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3 = function(arr, f, val) {
  var cnt = arr.length;
  var val__$1 = val;
  var n = 0;
  while (true) {
    if (n < cnt) {
      var nval = (function() {
        var G__9698 = val__$1;
        var G__9699 = arr[n];
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__9698, G__9699)
          : f.call(null, G__9698, G__9699);
      })();
      if (cljs.core.reduced_QMARK_(nval))
        return cljs.core.deref(nval);
      else {
        var G__9708 = nval;
        var G__9709 = n + 1;
        val__$1 = G__9708;
        n = G__9709;
        continue;
      }
    } else
      return val__$1;
    break;
  }
};
cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4 = function(
  arr,
  f,
  val,
  idx
) {
  var cnt = arr.length;
  var val__$1 = val;
  var n = idx;
  while (true) {
    if (n < cnt) {
      var nval = (function() {
        var G__9700 = val__$1;
        var G__9701 = arr[n];
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__9700, G__9701)
          : f.call(null, G__9700, G__9701);
      })();
      if (cljs.core.reduced_QMARK_(nval))
        return cljs.core.deref(nval);
      else {
        var G__9710 = nval;
        var G__9711 = n + 1;
        val__$1 = G__9710;
        n = G__9711;
        continue;
      }
    } else
      return val__$1;
    break;
  }
};
cljs.core.array_reduce.cljs$lang$maxFixedArity = 4;
cljs.core.counted_QMARK_ = function cljs$core$counted_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 2 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ICounted$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ICounted, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ICounted, x);
};
cljs.core.indexed_QMARK_ = function cljs$core$indexed_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 16 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IIndexed$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed, x);
};
cljs.core._indexOf = function cljs$core$_indexOf(var_args) {
  var args9716 = [];
  var len__8257__auto___9719 = arguments.length;
  var i__8258__auto___9720 = 0;
  while (true) {
    if (i__8258__auto___9720 < len__8257__auto___9719) {
      args9716.push(arguments[i__8258__auto___9720]);
      var G__9721 = i__8258__auto___9720 + 1;
      i__8258__auto___9720 = G__9721;
      continue;
    } else;
    break;
  }
  var G__9718 = args9716.length;
  switch (G__9718) {
    case 2:
      return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9716.length)
        ].join('')
      );
  }
};
cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2 = function(coll, x) {
  return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
};
cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3 = function(coll, x, start) {
  var len = cljs.core.count.cljs$core$IFn$_invoke$arity$1
    ? cljs.core.count.cljs$core$IFn$_invoke$arity$1(coll)
    : cljs.core.count.call(null, coll);
  if (start >= len)
    return -1;
  else {
    var idx = start > 0
      ? start
      : start < 0
          ? (function() {
              var x__7480__auto__ = 0;
              var y__7481__auto__ = start + len;
              return x__7480__auto__ > y__7481__auto__
                ? x__7480__auto__
                : y__7481__auto__;
            })()
          : start;
    while (true) {
      if (idx < len)
        if (
          cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
            cljs.core.nth.cljs$core$IFn$_invoke$arity$2
              ? cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll, idx)
              : cljs.core.nth.call(null, coll, idx),
            x
          )
        )
          return idx;
        else {
          var G__9723 = idx + 1;
          idx = G__9723;
          continue;
        }
      else
        return -1;
      break;
    }
  }
};
cljs.core._indexOf.cljs$lang$maxFixedArity = 3;
cljs.core._lastIndexOf = function cljs$core$_lastIndexOf(var_args) {
  var args9724 = [];
  var len__8257__auto___9727 = arguments.length;
  var i__8258__auto___9728 = 0;
  while (true) {
    if (i__8258__auto___9728 < len__8257__auto___9727) {
      args9724.push(arguments[i__8258__auto___9728]);
      var G__9729 = i__8258__auto___9728 + 1;
      i__8258__auto___9728 = G__9729;
      continue;
    } else;
    break;
  }
  var G__9726 = args9724.length;
  switch (G__9726) {
    case 2:
      return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9724.length)
        ].join('')
      );
  }
};
cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2 = function(coll, x) {
  return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
    coll,
    x,
    cljs.core.count.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.count.cljs$core$IFn$_invoke$arity$1(coll)
      : cljs.core.count.call(null, coll)
  );
};
cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3 = function(
  coll,
  x,
  start
) {
  var len = cljs.core.count.cljs$core$IFn$_invoke$arity$1
    ? cljs.core.count.cljs$core$IFn$_invoke$arity$1(coll)
    : cljs.core.count.call(null, coll);
  if (len === 0)
    return -1;
  else {
    var idx = start > 0
      ? (function() {
          var x__7487__auto__ = len - 1;
          var y__7488__auto__ = start;
          return x__7487__auto__ < y__7488__auto__
            ? x__7487__auto__
            : y__7488__auto__;
        })()
      : start < 0 ? len + start : start;
    while (true) {
      if (idx >= 0)
        if (
          cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
            cljs.core.nth.cljs$core$IFn$_invoke$arity$2
              ? cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll, idx)
              : cljs.core.nth.call(null, coll, idx),
            x
          )
        )
          return idx;
        else {
          var G__9731 = idx - 1;
          idx = G__9731;
          continue;
        }
      else
        return -1;
      break;
    }
  }
};
cljs.core._lastIndexOf.cljs$lang$maxFixedArity = 3;
cljs.core.IndexedSeqIterator = function(arr, i) {
  this.arr = arr;
  this.i = i;
};
cljs.core.IndexedSeqIterator.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  return self__.i < self__.arr.length;
};
cljs.core.IndexedSeqIterator.prototype.next = function() {
  var self__ = this;
  var _ = this;
  var ret = self__.arr[self__.i];
  self__.i = self__.i + 1;
  return ret;
};
cljs.core.IndexedSeqIterator.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.IndexedSeqIterator.cljs$lang$type = true;
cljs.core.IndexedSeqIterator.cljs$lang$ctorStr = 'cljs.core/IndexedSeqIterator';
cljs.core.IndexedSeqIterator.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/IndexedSeqIterator');
};
cljs.core.__GT_IndexedSeqIterator = function cljs$core$__GT_IndexedSeqIterator(
  arr,
  i
) {
  return new cljs.core.IndexedSeqIterator(arr, i);
};
cljs.core.IndexedSeq = function(arr, i, meta) {
  this.arr = arr;
  this.i = i;
  this.meta = meta;
  this.cljs$lang$protocol_mask$partition0$ = 166592766;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.IndexedSeq.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.IndexedSeq.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.IndexedSeq.prototype.indexOf = (function() {
  var G__9732 = null;
  var G__9732__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__9732__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__9732 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__9732__1.call(this, x);
      case 2:
        return G__9732__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9732.cljs$core$IFn$_invoke$arity$1 = G__9732__1;
  G__9732.cljs$core$IFn$_invoke$arity$2 = G__9732__2;
  return G__9732;
})();
cljs.core.IndexedSeq.prototype.lastIndexOf = (function() {
  var G__9733 = null;
  var G__9733__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.count.cljs$core$IFn$_invoke$arity$1(coll)
        : cljs.core.count.call(null, coll)
    );
  };
  var G__9733__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__9733 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__9733__1.call(this, x);
      case 2:
        return G__9733__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9733.cljs$core$IFn$_invoke$arity$1 = G__9733__1;
  G__9733.cljs$core$IFn$_invoke$arity$2 = G__9733__2;
  return G__9733;
})();
cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 = function(
  coll,
  n
) {
  var self__ = this;
  var coll__$1 = this;
  var i__$1 = n + self__.i;
  if (0 <= i__$1 && i__$1 < self__.arr.length) return self__.arr[i__$1];
  else throw new Error('Index out of bounds');
};
cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$3 = function(
  coll,
  n,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  var i__$1 = n + self__.i;
  if (0 <= i__$1 && i__$1 < self__.arr.length) return self__.arr[i__$1];
  else return not_found;
};
cljs.core.IndexedSeq.prototype.cljs$core$IIterable$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.IndexedSeq.prototype.cljs$core$IIterable$_iterator$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.IndexedSeqIterator(self__.arr, self__.i);
};
cljs.core.IndexedSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.IndexedSeq.prototype.cljs$core$ICloneable$_clone$arity$1 = function(
  _
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.IndexedSeq(self__.arr, self__.i, self__.meta);
};
cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  if (self__.i + 1 < self__.arr.length)
    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1, null);
  else
    return null;
};
cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  var x__7480__auto__ = 0;
  var y__7481__auto__ = self__.arr.length - self__.i;
  return x__7480__auto__ > y__7481__auto__ ? x__7480__auto__ : y__7481__auto__;
};
cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var c = coll__$1.cljs$core$ICounted$_count$arity$1(null);
  if (c > 0) return new cljs.core.RSeq(coll__$1, c - 1, null);
  else return null;
};
cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.hash_ordered_coll(coll__$1);
};
cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.equiv_sequential.cljs$core$IFn$_invoke$arity$2(coll__$1, other)
    : cljs.core.equiv_sequential.call(null, coll__$1, other);
};
cljs.core.IndexedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.List.EMPTY;
};
cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(
    self__.arr,
    f,
    self__.arr[self__.i],
    self__.i + 1
  );
};
cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(
    self__.arr,
    f,
    start,
    self__.i
  );
};
cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.arr[self__.i];
};
cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  if (self__.i + 1 < self__.arr.length)
    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1, null);
  else
    return cljs.core.List.EMPTY;
};
cljs.core.IndexedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  if (self__.i < self__.arr.length) return this$__$1;
  else return null;
};
cljs.core.IndexedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  new_meta
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.IndexedSeq(self__.arr, self__.i, new_meta);
};
cljs.core.IndexedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.cons.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.cons.cljs$core$IFn$_invoke$arity$2(o, coll__$1)
    : cljs.core.cons.call(null, o, coll__$1);
};
cljs.core.IndexedSeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null),
      new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null)
    ],
    null
  );
};
cljs.core.IndexedSeq.cljs$lang$type = true;
cljs.core.IndexedSeq.cljs$lang$ctorStr = 'cljs.core/IndexedSeq';
cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/IndexedSeq');
};
cljs.core.__GT_IndexedSeq = function cljs$core$__GT_IndexedSeq(arr, i, meta) {
  return new cljs.core.IndexedSeq(arr, i, meta);
};
cljs.core.IndexedSeq.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.prim_seq = function cljs$core$prim_seq(var_args) {
  var args9734 = [];
  var len__8257__auto___9737 = arguments.length;
  var i__8258__auto___9738 = 0;
  while (true) {
    if (i__8258__auto___9738 < len__8257__auto___9737) {
      args9734.push(arguments[i__8258__auto___9738]);
      var G__9739 = i__8258__auto___9738 + 1;
      i__8258__auto___9738 = G__9739;
      continue;
    } else;
    break;
  }
  var G__9736 = args9734.length;
  switch (G__9736) {
    case 1:
      return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9734.length)
        ].join('')
      );
  }
};
cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1 = function(prim) {
  return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(prim, 0);
};
cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2 = function(prim, i) {
  if (i < prim.length) return new cljs.core.IndexedSeq(prim, i, null);
  else return null;
};
cljs.core.prim_seq.cljs$lang$maxFixedArity = 2;
cljs.core.array_seq = function cljs$core$array_seq(var_args) {
  var args9741 = [];
  var len__8257__auto___9744 = arguments.length;
  var i__8258__auto___9745 = 0;
  while (true) {
    if (i__8258__auto___9745 < len__8257__auto___9744) {
      args9741.push(arguments[i__8258__auto___9745]);
      var G__9746 = i__8258__auto___9745 + 1;
      i__8258__auto___9745 = G__9746;
      continue;
    } else;
    break;
  }
  var G__9743 = args9741.length;
  switch (G__9743) {
    case 1:
      return cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9741.length)
        ].join('')
      );
  }
};
cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1 = function(array) {
  return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array, 0);
};
cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2 = function(array, i) {
  return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array, i);
};
cljs.core.array_seq.cljs$lang$maxFixedArity = 2;
cljs.core.RSeq = function(ci, i, meta) {
  this.ci = ci;
  this.i = i;
  this.meta = meta;
  this.cljs$lang$protocol_mask$partition0$ = 32374990;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.RSeq.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.RSeq.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.RSeq.prototype.indexOf = (function() {
  var G__9750 = null;
  var G__9750__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__9750__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__9750 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__9750__1.call(this, x);
      case 2:
        return G__9750__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9750.cljs$core$IFn$_invoke$arity$1 = G__9750__1;
  G__9750.cljs$core$IFn$_invoke$arity$2 = G__9750__2;
  return G__9750;
})();
cljs.core.RSeq.prototype.lastIndexOf = (function() {
  var G__9751 = null;
  var G__9751__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.count.cljs$core$IFn$_invoke$arity$1(coll)
        : cljs.core.count.call(null, coll)
    );
  };
  var G__9751__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__9751 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__9751__1.call(this, x);
      case 2:
        return G__9751__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9751.cljs$core$IFn$_invoke$arity$1 = G__9751__1;
  G__9751.cljs$core$IFn$_invoke$arity$2 = G__9751__2;
  return G__9751;
})();
cljs.core.RSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.RSeq.prototype.cljs$core$ICloneable$_clone$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.RSeq(self__.ci, self__.i, self__.meta);
};
cljs.core.RSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.i > 0) return new cljs.core.RSeq(self__.ci, self__.i - 1, null);
  else return null;
};
cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.i + 1;
};
cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.hash_ordered_coll(coll__$1);
};
cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.equiv_sequential.cljs$core$IFn$_invoke$arity$2(coll__$1, other)
    : cljs.core.equiv_sequential.call(null, coll__$1, other);
};
cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var G__9748 = cljs.core.List.EMPTY;
  var G__9749 = self__.meta;
  return cljs.core.with_meta.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.with_meta.cljs$core$IFn$_invoke$arity$2(G__9748, G__9749)
    : cljs.core.with_meta.call(null, G__9748, G__9749);
};
cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(col, f) {
  var self__ = this;
  var col__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, col__$1)
    : cljs.core.seq_reduce.call(null, f, col__$1);
};
cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  col,
  f,
  start
) {
  var self__ = this;
  var col__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3
    ? cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, start, col__$1)
    : cljs.core.seq_reduce.call(null, f, start, col__$1);
};
cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.ci, self__.i);
};
cljs.core.RSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.i > 0) return new cljs.core.RSeq(self__.ci, self__.i - 1, null);
  else return cljs.core.List.EMPTY;
};
cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  new_meta
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.RSeq(self__.ci, self__.i, new_meta);
};
cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.cons.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.cons.cljs$core$IFn$_invoke$arity$2(o, coll__$1)
    : cljs.core.cons.call(null, o, coll__$1);
};
cljs.core.RSeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'ci', 'ci', 2049808339, null),
      new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null)
    ],
    null
  );
};
cljs.core.RSeq.cljs$lang$type = true;
cljs.core.RSeq.cljs$lang$ctorStr = 'cljs.core/RSeq';
cljs.core.RSeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/RSeq');
};
cljs.core.__GT_RSeq = function cljs$core$__GT_RSeq(ci, i, meta) {
  return new cljs.core.RSeq(ci, i, meta);
};
cljs.core.RSeq.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.second = function cljs$core$second(coll) {
  return cljs.core.first(cljs.core.next(coll));
};
cljs.core.ffirst = function cljs$core$ffirst(coll) {
  return cljs.core.first(cljs.core.first(coll));
};
cljs.core.nfirst = function cljs$core$nfirst(coll) {
  return cljs.core.next(cljs.core.first(coll));
};
cljs.core.fnext = function cljs$core$fnext(coll) {
  return cljs.core.first(cljs.core.next(coll));
};
cljs.core.nnext = function cljs$core$nnext(coll) {
  return cljs.core.next(cljs.core.next(coll));
};
cljs.core.last = function cljs$core$last(s) {
  while (true) {
    var sn = cljs.core.next(s);
    if (!(sn == null)) {
      var G__9752 = sn;
      s = G__9752;
      continue;
    } else
      return cljs.core.first(s);
    break;
  }
};
cljs.core.IEquiv['_'] = true;
cljs.core._equiv['_'] = function(x, o) {
  return x === o;
};
cljs.core.conj = function cljs$core$conj(var_args) {
  var args9753 = [];
  var len__8257__auto___9759 = arguments.length;
  var i__8258__auto___9760 = 0;
  while (true) {
    if (i__8258__auto___9760 < len__8257__auto___9759) {
      args9753.push(arguments[i__8258__auto___9760]);
      var G__9761 = i__8258__auto___9760 + 1;
      i__8258__auto___9760 = G__9761;
      continue;
    } else;
    break;
  }
  var G__9758 = args9753.length;
  switch (G__9758) {
    case 0:
      return cljs.core.conj.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.conj.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9753.slice(2),
        0,
        null
      );
      return cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.conj.cljs$core$IFn$_invoke$arity$0 = function() {
  return cljs.core.PersistentVector.EMPTY;
};
cljs.core.conj.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  return coll;
};
cljs.core.conj.cljs$core$IFn$_invoke$arity$2 = function(coll, x) {
  if (!(coll == null))
    return cljs.core._conj(coll, x);
  else {
    var x__7986__auto__ = x;
    return cljs.core._conj(cljs.core.List.EMPTY, x__7986__auto__);
  }
};
cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic = function(coll, x, xs) {
  while (true) {
    if (cljs.core.truth_(xs)) {
      var G__9763 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll, x);
      var G__9764 = cljs.core.first(xs);
      var G__9765 = cljs.core.next(xs);
      coll = G__9763;
      x = G__9764;
      xs = G__9765;
      continue;
    } else
      return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll, x);
    break;
  }
};
cljs.core.conj.cljs$lang$applyTo = function(seq9754) {
  var G__9755 = cljs.core.first(seq9754);
  var seq9754__$1 = cljs.core.next(seq9754);
  var G__9756 = cljs.core.first(seq9754__$1);
  var seq9754__$2 = cljs.core.next(seq9754__$1);
  return cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(
    G__9755,
    G__9756,
    seq9754__$2
  );
};
cljs.core.conj.cljs$lang$maxFixedArity = 2;
cljs.core.empty = function cljs$core$empty(coll) {
  if (coll == null) return null;
  else return cljs.core._empty(coll);
};
cljs.core.accumulating_seq_count = function cljs$core$accumulating_seq_count(
  coll
) {
  var s = cljs.core.seq(coll);
  var acc = 0;
  while (true) {
    if (cljs.core.counted_QMARK_(s))
      return acc + cljs.core._count(s);
    else {
      var G__9766 = cljs.core.next(s);
      var G__9767 = acc + 1;
      s = G__9766;
      acc = G__9767;
      continue;
    }
    break;
  }
};
cljs.core.count = function cljs$core$count(coll) {
  if (!(coll == null))
    if (
      !(coll == null)
        ? coll.cljs$lang$protocol_mask$partition0$ & 2 ||
            cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ICounted$
            ? true
            : false
        : false
    )
      return coll.cljs$core$ICounted$_count$arity$1(null);
    else if (cljs.core.array_QMARK_(coll)) return coll.length;
    else if (typeof coll === 'string') return coll.length;
    else if (
      !(coll == null)
        ? coll.cljs$lang$protocol_mask$partition0$ & 8388608 ||
            cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeqable$
            ? true
            : false
        : false
    )
      return cljs.core.accumulating_seq_count(coll);
    else
      return cljs.core._count(coll);
  else
    return 0;
};
cljs.core.linear_traversal_nth = function cljs$core$linear_traversal_nth(
  var_args
) {
  var args9772 = [];
  var len__8257__auto___9775 = arguments.length;
  var i__8258__auto___9776 = 0;
  while (true) {
    if (i__8258__auto___9776 < len__8257__auto___9775) {
      args9772.push(arguments[i__8258__auto___9776]);
      var G__9777 = i__8258__auto___9776 + 1;
      i__8258__auto___9776 = G__9777;
      continue;
    } else;
    break;
  }
  var G__9774 = args9772.length;
  switch (G__9774) {
    case 2:
      return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9772.length)
        ].join('')
      );
  }
};
cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2 = function(
  coll,
  n
) {
  while (true) {
    if (coll == null)
      throw new Error('Index out of bounds');
    else if (n === 0)
      if (cljs.core.seq(coll)) return cljs.core.first(coll);
      else throw new Error('Index out of bounds');
    else if (cljs.core.indexed_QMARK_(coll))
      return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(coll, n);
    else if (cljs.core.seq(coll)) {
      var G__9779 = cljs.core.next(coll);
      var G__9780 = n - 1;
      coll = G__9779;
      n = G__9780;
      continue;
    } else
      throw new Error('Index out of bounds');
    break;
  }
};
cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3 = function(
  coll,
  n,
  not_found
) {
  while (true) {
    if (coll == null)
      return not_found;
    else if (n === 0)
      if (cljs.core.seq(coll)) return cljs.core.first(coll);
      else return not_found;
    else if (cljs.core.indexed_QMARK_(coll))
      return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(coll, n, not_found);
    else if (cljs.core.seq(coll)) {
      var G__9781 = cljs.core.next(coll);
      var G__9782 = n - 1;
      var G__9783 = not_found;
      coll = G__9781;
      n = G__9782;
      not_found = G__9783;
      continue;
    } else
      return not_found;
    break;
  }
};
cljs.core.linear_traversal_nth.cljs$lang$maxFixedArity = 3;
cljs.core.nth = function cljs$core$nth(var_args) {
  var args9784 = [];
  var len__8257__auto___9791 = arguments.length;
  var i__8258__auto___9792 = 0;
  while (true) {
    if (i__8258__auto___9792 < len__8257__auto___9791) {
      args9784.push(arguments[i__8258__auto___9792]);
      var G__9793 = i__8258__auto___9792 + 1;
      i__8258__auto___9792 = G__9793;
      continue;
    } else;
    break;
  }
  var G__9786 = args9784.length;
  switch (G__9786) {
    case 2:
      return cljs.core.nth.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9784.length)
        ].join('')
      );
  }
};
cljs.core.nth.cljs$core$IFn$_invoke$arity$2 = function(coll, n) {
  if (!(typeof n === 'number'))
    throw new Error('Index argument to nth must be a number');
  else if (coll == null) return coll;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 16 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IIndexed$
          ? true
          : false
      : false
  )
    return coll.cljs$core$IIndexed$_nth$arity$2(null, n);
  else if (cljs.core.array_QMARK_(coll))
    if (n >= 0 && n < coll.length) return coll[n];
    else throw new Error('Index out of bounds');
  else if (typeof coll === 'string')
    if (n >= 0 && n < coll.length) return coll.charAt(n);
    else throw new Error('Index out of bounds');
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 64 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$
          ? true
          : false
      : false
  )
    return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2(
      coll,
      n
    );
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed, coll))
    return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(coll, n);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          'nth not supported on this type '
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          cljs.core.type__GT_str(cljs.core.type(coll))
        )
      ].join('')
    );
};
cljs.core.nth.cljs$core$IFn$_invoke$arity$3 = function(coll, n, not_found) {
  if (!(typeof n === 'number'))
    throw new Error('Index argument to nth must be a number.');
  else if (coll == null) return not_found;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 16 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IIndexed$
          ? true
          : false
      : false
  )
    return coll.cljs$core$IIndexed$_nth$arity$3(null, n, not_found);
  else if (cljs.core.array_QMARK_(coll))
    if (n >= 0 && n < coll.length) return coll[n];
    else return not_found;
  else if (typeof coll === 'string')
    if (n >= 0 && n < coll.length) return coll.charAt(n);
    else return not_found;
  else if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 64 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$
          ? true
          : false
      : false
  )
    return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3(
      coll,
      n,
      not_found
    );
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed, coll))
    return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(coll, n);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          'nth not supported on this type '
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          cljs.core.type__GT_str(cljs.core.type(coll))
        )
      ].join('')
    );
};
cljs.core.nth.cljs$lang$maxFixedArity = 3;
cljs.core.nthrest = function cljs$core$nthrest(coll, n) {
  var n__$1 = n;
  var xs = coll;
  while (true) {
    if (n__$1 > 0 && cljs.core.seq(xs)) {
      var G__9795 = n__$1 - 1;
      var G__9796 = cljs.core.rest(xs);
      n__$1 = G__9795;
      xs = G__9796;
      continue;
    } else
      return xs;
    break;
  }
};
cljs.core.get = function cljs$core$get(var_args) {
  var args9797 = [];
  var len__8257__auto___9802 = arguments.length;
  var i__8258__auto___9803 = 0;
  while (true) {
    if (i__8258__auto___9803 < len__8257__auto___9802) {
      args9797.push(arguments[i__8258__auto___9803]);
      var G__9804 = i__8258__auto___9803 + 1;
      i__8258__auto___9803 = G__9804;
      continue;
    } else;
    break;
  }
  var G__9799 = args9797.length;
  switch (G__9799) {
    case 2:
      return cljs.core.get.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.get.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9797.length)
        ].join('')
      );
  }
};
cljs.core.get.cljs$core$IFn$_invoke$arity$2 = function(o, k) {
  if (o == null) return null;
  else if (
    !(o == null)
      ? o.cljs$lang$protocol_mask$partition0$ & 256 ||
          cljs.core.PROTOCOL_SENTINEL === o.cljs$core$ILookup$
          ? true
          : false
      : false
  )
    return o.cljs$core$ILookup$_lookup$arity$2(null, k);
  else if (cljs.core.array_QMARK_(o))
    if (!(k == null) && k < o.length) return o[k | 0];
    else return null;
  else if (typeof o === 'string')
    if (!(k == null) && k < o.length) return o.charAt(k | 0);
    else return null;
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.ILookup, o))
    return cljs.core._lookup.cljs$core$IFn$_invoke$arity$2(o, k);
  else
    return null;
};
cljs.core.get.cljs$core$IFn$_invoke$arity$3 = function(o, k, not_found) {
  if (!(o == null))
    if (
      !(o == null)
        ? o.cljs$lang$protocol_mask$partition0$ & 256 ||
            cljs.core.PROTOCOL_SENTINEL === o.cljs$core$ILookup$
            ? true
            : false
        : false
    )
      return o.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
    else if (cljs.core.array_QMARK_(o))
      if (!(k == null) && k >= 0 && k < o.length) return o[k | 0];
      else return not_found;
    else if (typeof o === 'string')
      if (!(k == null) && k >= 0 && k < o.length) return o.charAt(k | 0);
      else return not_found;
    else if (cljs.core.native_satisfies_QMARK_(cljs.core.ILookup, o))
      return cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(o, k, not_found);
    else
      return not_found;
  else
    return not_found;
};
cljs.core.get.cljs$lang$maxFixedArity = 3;
cljs.core.assoc = function cljs$core$assoc(var_args) {
  var args9806 = [];
  var len__8257__auto___9813 = arguments.length;
  var i__8258__auto___9814 = 0;
  while (true) {
    if (i__8258__auto___9814 < len__8257__auto___9813) {
      args9806.push(arguments[i__8258__auto___9814]);
      var G__9815 = i__8258__auto___9814 + 1;
      i__8258__auto___9814 = G__9815;
      continue;
    } else;
    break;
  }
  var G__9812 = args9806.length;
  switch (G__9812) {
    case 3:
      return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9806.slice(3),
        0,
        null
      );
      return cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.assoc.cljs$core$IFn$_invoke$arity$3 = function(coll, k, v) {
  if (!(coll == null)) return cljs.core._assoc(coll, k, v);
  else return cljs.core.PersistentHashMap.fromArrays([k], [v]);
};
cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic = function(
  coll,
  k,
  v,
  kvs
) {
  while (true) {
    var ret = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(coll, k, v);
    if (cljs.core.truth_(kvs)) {
      var G__9817 = ret;
      var G__9818 = cljs.core.first(kvs);
      var G__9819 = cljs.core.second(kvs);
      var G__9820 = cljs.core.nnext(kvs);
      coll = G__9817;
      k = G__9818;
      v = G__9819;
      kvs = G__9820;
      continue;
    } else
      return ret;
    break;
  }
};
cljs.core.assoc.cljs$lang$applyTo = function(seq9807) {
  var G__9808 = cljs.core.first(seq9807);
  var seq9807__$1 = cljs.core.next(seq9807);
  var G__9809 = cljs.core.first(seq9807__$1);
  var seq9807__$2 = cljs.core.next(seq9807__$1);
  var G__9810 = cljs.core.first(seq9807__$2);
  var seq9807__$3 = cljs.core.next(seq9807__$2);
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(
    G__9808,
    G__9809,
    G__9810,
    seq9807__$3
  );
};
cljs.core.assoc.cljs$lang$maxFixedArity = 3;
cljs.core.dissoc = function cljs$core$dissoc(var_args) {
  var args9821 = [];
  var len__8257__auto___9827 = arguments.length;
  var i__8258__auto___9828 = 0;
  while (true) {
    if (i__8258__auto___9828 < len__8257__auto___9827) {
      args9821.push(arguments[i__8258__auto___9828]);
      var G__9829 = i__8258__auto___9828 + 1;
      i__8258__auto___9828 = G__9829;
      continue;
    } else;
    break;
  }
  var G__9826 = args9821.length;
  switch (G__9826) {
    case 1:
      return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9821.slice(2),
        0,
        null
      );
      return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  return coll;
};
cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2 = function(coll, k) {
  if (coll == null) return null;
  else return cljs.core._dissoc(coll, k);
};
cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic = function(coll, k, ks) {
  while (true) {
    if (coll == null)
      return null;
    else {
      var ret = cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(coll, k);
      if (cljs.core.truth_(ks)) {
        var G__9831 = ret;
        var G__9832 = cljs.core.first(ks);
        var G__9833 = cljs.core.next(ks);
        coll = G__9831;
        k = G__9832;
        ks = G__9833;
        continue;
      } else
        return ret;
    }
    break;
  }
};
cljs.core.dissoc.cljs$lang$applyTo = function(seq9822) {
  var G__9823 = cljs.core.first(seq9822);
  var seq9822__$1 = cljs.core.next(seq9822);
  var G__9824 = cljs.core.first(seq9822__$1);
  var seq9822__$2 = cljs.core.next(seq9822__$1);
  return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(
    G__9823,
    G__9824,
    seq9822__$2
  );
};
cljs.core.dissoc.cljs$lang$maxFixedArity = 2;
cljs.core.fn_QMARK_ = function cljs$core$fn_QMARK_(f) {
  var or__7144__auto__ = goog.isFunction(f);
  if (or__7144__auto__) return or__7144__auto__;
  else if (!(f == null))
    if (false || cljs.core.PROTOCOL_SENTINEL === f.cljs$core$Fn$) return true;
    else if (!f.cljs$lang$protocol_mask$partition$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.Fn, f);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.Fn, f);
};
cljs.core.MetaFn = function(afn, meta) {
  this.afn = afn;
  this.meta = meta;
  this.cljs$lang$protocol_mask$partition0$ = 393217;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.MetaFn.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.meta;
};
cljs.core.MetaFn.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  _,
  new_meta
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.MetaFn(self__.afn, new_meta);
};
cljs.core.MetaFn.prototype.cljs$core$Fn$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.MetaFn.prototype.call = (function() {
  var G__9839 = null;
  var G__9839__1 = function(self__) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$0
      ? self__.afn.cljs$core$IFn$_invoke$arity$0()
      : self__.afn.call(null);
  };
  var G__9839__2 = function(self__, a) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$1
      ? self__.afn.cljs$core$IFn$_invoke$arity$1(a)
      : self__.afn.call(null, a);
  };
  var G__9839__3 = function(self__, a, b) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$2
      ? self__.afn.cljs$core$IFn$_invoke$arity$2(a, b)
      : self__.afn.call(null, a, b);
  };
  var G__9839__4 = function(self__, a, b, c) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$3
      ? self__.afn.cljs$core$IFn$_invoke$arity$3(a, b, c)
      : self__.afn.call(null, a, b, c);
  };
  var G__9839__5 = function(self__, a, b, c, d) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$4
      ? self__.afn.cljs$core$IFn$_invoke$arity$4(a, b, c, d)
      : self__.afn.call(null, a, b, c, d);
  };
  var G__9839__6 = function(self__, a, b, c, d, e) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$5
      ? self__.afn.cljs$core$IFn$_invoke$arity$5(a, b, c, d, e)
      : self__.afn.call(null, a, b, c, d, e);
  };
  var G__9839__7 = function(self__, a, b, c, d, e, f) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$6
      ? self__.afn.cljs$core$IFn$_invoke$arity$6(a, b, c, d, e, f)
      : self__.afn.call(null, a, b, c, d, e, f);
  };
  var G__9839__8 = function(self__, a, b, c, d, e, f, g) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$7
      ? self__.afn.cljs$core$IFn$_invoke$arity$7(a, b, c, d, e, f, g)
      : self__.afn.call(null, a, b, c, d, e, f, g);
  };
  var G__9839__9 = function(self__, a, b, c, d, e, f, g, h) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$8
      ? self__.afn.cljs$core$IFn$_invoke$arity$8(a, b, c, d, e, f, g, h)
      : self__.afn.call(null, a, b, c, d, e, f, g, h);
  };
  var G__9839__10 = function(self__, a, b, c, d, e, f, g, h, i) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$9
      ? self__.afn.cljs$core$IFn$_invoke$arity$9(a, b, c, d, e, f, g, h, i)
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i);
  };
  var G__9839__11 = function(self__, a, b, c, d, e, f, g, h, i, j) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$10
      ? self__.afn.cljs$core$IFn$_invoke$arity$10(a, b, c, d, e, f, g, h, i, j)
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j);
  };
  var G__9839__12 = function(self__, a, b, c, d, e, f, g, h, i, j, k) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$11
      ? self__.afn.cljs$core$IFn$_invoke$arity$11(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k);
  };
  var G__9839__13 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$12
      ? self__.afn.cljs$core$IFn$_invoke$arity$12(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l);
  };
  var G__9839__14 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l, m) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$13
      ? self__.afn.cljs$core$IFn$_invoke$arity$13(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m);
  };
  var G__9839__15 = function(self__, a, b, c, d, e, f, g, h, i, j, k, l, m, n) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$14
      ? self__.afn.cljs$core$IFn$_invoke$arity$14(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
  };
  var G__9839__16 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$15
      ? self__.afn.cljs$core$IFn$_invoke$arity$15(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
  };
  var G__9839__17 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$16
      ? self__.afn.cljs$core$IFn$_invoke$arity$16(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p
        )
      : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
  };
  var G__9839__18 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$17
      ? self__.afn.cljs$core$IFn$_invoke$arity$17(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q
        )
      : self__.afn.call(
          null,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q
        );
  };
  var G__9839__19 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$18
      ? self__.afn.cljs$core$IFn$_invoke$arity$18(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r
        )
      : self__.afn.call(
          null,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r
        );
  };
  var G__9839__20 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$19
      ? self__.afn.cljs$core$IFn$_invoke$arity$19(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s
        )
      : self__.afn.call(
          null,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s
        );
  };
  var G__9839__21 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return self__.afn.cljs$core$IFn$_invoke$arity$20
      ? self__.afn.cljs$core$IFn$_invoke$arity$20(
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t
        )
      : self__.afn.call(
          null,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t
        );
  };
  var G__9839__22 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    rest
  ) {
    var self__ = this;
    var self____$1 = this;
    var _ = self____$1;
    return cljs.core.apply.cljs$core$IFn$_invoke$arity$22
      ? cljs.core.apply.cljs$core$IFn$_invoke$arity$22(
          self__.afn,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t,
          rest
        )
      : cljs.core.apply.call(
          null,
          self__.afn,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t,
          rest
        );
  };
  G__9839 = function(
    self__,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    rest
  ) {
    switch (arguments.length) {
      case 1:
        return G__9839__1.call(this, self__);
      case 2:
        return G__9839__2.call(this, self__, a);
      case 3:
        return G__9839__3.call(this, self__, a, b);
      case 4:
        return G__9839__4.call(this, self__, a, b, c);
      case 5:
        return G__9839__5.call(this, self__, a, b, c, d);
      case 6:
        return G__9839__6.call(this, self__, a, b, c, d, e);
      case 7:
        return G__9839__7.call(this, self__, a, b, c, d, e, f);
      case 8:
        return G__9839__8.call(this, self__, a, b, c, d, e, f, g);
      case 9:
        return G__9839__9.call(this, self__, a, b, c, d, e, f, g, h);
      case 10:
        return G__9839__10.call(this, self__, a, b, c, d, e, f, g, h, i);
      case 11:
        return G__9839__11.call(this, self__, a, b, c, d, e, f, g, h, i, j);
      case 12:
        return G__9839__12.call(this, self__, a, b, c, d, e, f, g, h, i, j, k);
      case 13:
        return G__9839__13.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l
        );
      case 14:
        return G__9839__14.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m
        );
      case 15:
        return G__9839__15.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n
        );
      case 16:
        return G__9839__16.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o
        );
      case 17:
        return G__9839__17.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p
        );
      case 18:
        return G__9839__18.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q
        );
      case 19:
        return G__9839__19.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r
        );
      case 20:
        return G__9839__20.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s
        );
      case 21:
        return G__9839__21.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t
        );
      case 22:
        return G__9839__22.call(
          this,
          self__,
          a,
          b,
          c,
          d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s,
          t,
          rest
        );
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__9839.cljs$core$IFn$_invoke$arity$1 = G__9839__1;
  G__9839.cljs$core$IFn$_invoke$arity$2 = G__9839__2;
  G__9839.cljs$core$IFn$_invoke$arity$3 = G__9839__3;
  G__9839.cljs$core$IFn$_invoke$arity$4 = G__9839__4;
  G__9839.cljs$core$IFn$_invoke$arity$5 = G__9839__5;
  G__9839.cljs$core$IFn$_invoke$arity$6 = G__9839__6;
  G__9839.cljs$core$IFn$_invoke$arity$7 = G__9839__7;
  G__9839.cljs$core$IFn$_invoke$arity$8 = G__9839__8;
  G__9839.cljs$core$IFn$_invoke$arity$9 = G__9839__9;
  G__9839.cljs$core$IFn$_invoke$arity$10 = G__9839__10;
  G__9839.cljs$core$IFn$_invoke$arity$11 = G__9839__11;
  G__9839.cljs$core$IFn$_invoke$arity$12 = G__9839__12;
  G__9839.cljs$core$IFn$_invoke$arity$13 = G__9839__13;
  G__9839.cljs$core$IFn$_invoke$arity$14 = G__9839__14;
  G__9839.cljs$core$IFn$_invoke$arity$15 = G__9839__15;
  G__9839.cljs$core$IFn$_invoke$arity$16 = G__9839__16;
  G__9839.cljs$core$IFn$_invoke$arity$17 = G__9839__17;
  G__9839.cljs$core$IFn$_invoke$arity$18 = G__9839__18;
  G__9839.cljs$core$IFn$_invoke$arity$19 = G__9839__19;
  G__9839.cljs$core$IFn$_invoke$arity$20 = G__9839__20;
  G__9839.cljs$core$IFn$_invoke$arity$21 = G__9839__21;
  G__9839.cljs$core$IFn$_invoke$arity$22 = G__9839__22;
  return G__9839;
})();
cljs.core.MetaFn.prototype.apply = function(self__, args9838) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args9838))
  );
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$0 = function() {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$0
    ? self__.afn.cljs$core$IFn$_invoke$arity$0()
    : self__.afn.call(null);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$1 = function(a) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$1
    ? self__.afn.cljs$core$IFn$_invoke$arity$1(a)
    : self__.afn.call(null, a);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$2 = function(a, b) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$2
    ? self__.afn.cljs$core$IFn$_invoke$arity$2(a, b)
    : self__.afn.call(null, a, b);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$3 = function(a, b, c) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$3
    ? self__.afn.cljs$core$IFn$_invoke$arity$3(a, b, c)
    : self__.afn.call(null, a, b, c);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$4 = function(
  a,
  b,
  c,
  d
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$4
    ? self__.afn.cljs$core$IFn$_invoke$arity$4(a, b, c, d)
    : self__.afn.call(null, a, b, c, d);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$5 = function(
  a,
  b,
  c,
  d,
  e
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$5
    ? self__.afn.cljs$core$IFn$_invoke$arity$5(a, b, c, d, e)
    : self__.afn.call(null, a, b, c, d, e);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$6 = function(
  a,
  b,
  c,
  d,
  e,
  f
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$6
    ? self__.afn.cljs$core$IFn$_invoke$arity$6(a, b, c, d, e, f)
    : self__.afn.call(null, a, b, c, d, e, f);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$7 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$7
    ? self__.afn.cljs$core$IFn$_invoke$arity$7(a, b, c, d, e, f, g)
    : self__.afn.call(null, a, b, c, d, e, f, g);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$8 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$8
    ? self__.afn.cljs$core$IFn$_invoke$arity$8(a, b, c, d, e, f, g, h)
    : self__.afn.call(null, a, b, c, d, e, f, g, h);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$9 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$9
    ? self__.afn.cljs$core$IFn$_invoke$arity$9(a, b, c, d, e, f, g, h, i)
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$10 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$10
    ? self__.afn.cljs$core$IFn$_invoke$arity$10(a, b, c, d, e, f, g, h, i, j)
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$11 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$11
    ? self__.afn.cljs$core$IFn$_invoke$arity$11(a, b, c, d, e, f, g, h, i, j, k)
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$12 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$12
    ? self__.afn.cljs$core$IFn$_invoke$arity$12(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$13 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$13
    ? self__.afn.cljs$core$IFn$_invoke$arity$13(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$14 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$14
    ? self__.afn.cljs$core$IFn$_invoke$arity$14(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$15 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$15
    ? self__.afn.cljs$core$IFn$_invoke$arity$15(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$16 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$16
    ? self__.afn.cljs$core$IFn$_invoke$arity$16(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$17 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$17
    ? self__.afn.cljs$core$IFn$_invoke$arity$17(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q
      )
    : self__.afn.call(null, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$18 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$18
    ? self__.afn.cljs$core$IFn$_invoke$arity$18(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r
      )
    : self__.afn.call(
        null,
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r
      );
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$19 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$19
    ? self__.afn.cljs$core$IFn$_invoke$arity$19(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s
      )
    : self__.afn.call(
        null,
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s
      );
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$20 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t
) {
  var self__ = this;
  var _ = this;
  return self__.afn.cljs$core$IFn$_invoke$arity$20
    ? self__.afn.cljs$core$IFn$_invoke$arity$20(
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s,
        t
      )
    : self__.afn.call(
        null,
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s,
        t
      );
};
cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$21 = function(
  a,
  b,
  c,
  d,
  e,
  f,
  g,
  h,
  i,
  j,
  k,
  l,
  m,
  n,
  o,
  p,
  q,
  r,
  s,
  t,
  rest
) {
  var self__ = this;
  var _ = this;
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$22
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$22(
        self__.afn,
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s,
        t,
        rest
      )
    : cljs.core.apply.call(
        null,
        self__.afn,
        a,
        b,
        c,
        d,
        e,
        f,
        g,
        h,
        i,
        j,
        k,
        l,
        m,
        n,
        o,
        p,
        q,
        r,
        s,
        t,
        rest
      );
};
cljs.core.MetaFn.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'afn', 'afn', 216963467, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null)
    ],
    null
  );
};
cljs.core.MetaFn.cljs$lang$type = true;
cljs.core.MetaFn.cljs$lang$ctorStr = 'cljs.core/MetaFn';
cljs.core.MetaFn.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/MetaFn');
};
cljs.core.__GT_MetaFn = function cljs$core$__GT_MetaFn(afn, meta) {
  return new cljs.core.MetaFn(afn, meta);
};
cljs.core.with_meta = function cljs$core$with_meta(o, meta) {
  if (goog.isFunction(o)) return new cljs.core.MetaFn(o, meta);
  else if (o == null) return null;
  else return cljs.core._with_meta(o, meta);
};
cljs.core.meta = function cljs$core$meta(o) {
  if (
    (function() {
      var and__7132__auto__ = !(o == null);
      if (and__7132__auto__)
        if (!(o == null))
          if (
            o.cljs$lang$protocol_mask$partition0$ & 131072 ||
            cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IMeta$
          )
            return true;
          else if (!o.cljs$lang$protocol_mask$partition0$)
            return cljs.core.native_satisfies_QMARK_(cljs.core.IMeta, o);
          else
            return false;
        else
          return cljs.core.native_satisfies_QMARK_(cljs.core.IMeta, o);
      else
        return and__7132__auto__;
    })()
  )
    return cljs.core._meta(o);
  else
    return null;
};
cljs.core.peek = function cljs$core$peek(coll) {
  if (coll == null) return null;
  else return cljs.core._peek(coll);
};
cljs.core.pop = function cljs$core$pop(coll) {
  if (coll == null) return null;
  else return cljs.core._pop(coll);
};
cljs.core.disj = function cljs$core$disj(var_args) {
  var args9844 = [];
  var len__8257__auto___9850 = arguments.length;
  var i__8258__auto___9851 = 0;
  while (true) {
    if (i__8258__auto___9851 < len__8257__auto___9850) {
      args9844.push(arguments[i__8258__auto___9851]);
      var G__9852 = i__8258__auto___9851 + 1;
      i__8258__auto___9851 = G__9852;
      continue;
    } else;
    break;
  }
  var G__9849 = args9844.length;
  switch (G__9849) {
    case 1:
      return cljs.core.disj.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.disj.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9844.slice(2),
        0,
        null
      );
      return cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.disj.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  return coll;
};
cljs.core.disj.cljs$core$IFn$_invoke$arity$2 = function(coll, k) {
  if (coll == null) return null;
  else return cljs.core._disjoin(coll, k);
};
cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic = function(coll, k, ks) {
  while (true) {
    if (coll == null)
      return null;
    else {
      var ret = cljs.core.disj.cljs$core$IFn$_invoke$arity$2(coll, k);
      if (cljs.core.truth_(ks)) {
        var G__9854 = ret;
        var G__9855 = cljs.core.first(ks);
        var G__9856 = cljs.core.next(ks);
        coll = G__9854;
        k = G__9855;
        ks = G__9856;
        continue;
      } else
        return ret;
    }
    break;
  }
};
cljs.core.disj.cljs$lang$applyTo = function(seq9845) {
  var G__9846 = cljs.core.first(seq9845);
  var seq9845__$1 = cljs.core.next(seq9845);
  var G__9847 = cljs.core.first(seq9845__$1);
  var seq9845__$2 = cljs.core.next(seq9845__$1);
  return cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic(
    G__9846,
    G__9847,
    seq9845__$2
  );
};
cljs.core.disj.cljs$lang$maxFixedArity = 2;
cljs.core.empty_QMARK_ = function cljs$core$empty_QMARK_(coll) {
  return coll == null || cljs.core.not(cljs.core.seq(coll));
};
cljs.core.coll_QMARK_ = function cljs$core$coll_QMARK_(x) {
  if (x == null) return false;
  else if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 8 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ICollection$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ICollection, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ICollection, x);
};
cljs.core.set_QMARK_ = function cljs$core$set_QMARK_(x) {
  if (x == null) return false;
  else if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 4096 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISet$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ISet, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ISet, x);
};
cljs.core.associative_QMARK_ = function cljs$core$associative_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 512 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IAssociative$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative, x);
};
cljs.core.sequential_QMARK_ = function cljs$core$sequential_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 16777216 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISequential$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ISequential, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ISequential, x);
};
cljs.core.sorted_QMARK_ = function cljs$core$sorted_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 268435456 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISorted$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ISorted, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ISorted, x);
};
cljs.core.reduceable_QMARK_ = function cljs$core$reduceable_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 524288 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IReduce$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IReduce, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IReduce, x);
};
cljs.core.map_QMARK_ = function cljs$core$map_QMARK_(x) {
  if (x == null) return false;
  else if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 1024 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IMap$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IMap, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IMap, x);
};
cljs.core.record_QMARK_ = function cljs$core$record_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 67108864 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IRecord$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IRecord, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IRecord, x);
};
cljs.core.vector_QMARK_ = function cljs$core$vector_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 16384 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IVector$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IVector, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IVector, x);
};
cljs.core.chunked_seq_QMARK_ = function cljs$core$chunked_seq_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition1$ & 512 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IChunkedSeq$
    )
      return true;
    else
      return false;
  else
    return false;
};
cljs.core.js_obj = function cljs$core$js_obj(var_args) {
  var args9877 = [];
  var len__8257__auto___9883 = arguments.length;
  var i__8258__auto___9884 = 0;
  while (true) {
    if (i__8258__auto___9884 < len__8257__auto___9883) {
      args9877.push(arguments[i__8258__auto___9884]);
      var G__9885 = i__8258__auto___9884 + 1;
      i__8258__auto___9884 = G__9885;
      continue;
    } else;
    break;
  }
  var G__9880 = args9877.length;
  switch (G__9880) {
    case 0:
      return cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0();
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9877.slice(0),
        0,
        null
      );
      return cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic(
        argseq__8276__auto__
      );
  }
};
cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0 = function() {
  return {};
};
cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic = function(keyvals) {
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$2(goog.object.create, keyvals)
    : cljs.core.apply.call(null, goog.object.create, keyvals);
};
cljs.core.js_obj.cljs$lang$applyTo = function(seq9878) {
  return cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic(
    cljs.core.seq(seq9878)
  );
};
cljs.core.js_obj.cljs$lang$maxFixedArity = 0;
cljs.core.js_keys = function cljs$core$js_keys(obj) {
  var keys = [];
  var G__9889_9891 = obj;
  var G__9890_9892 = (function(G__9889_9891, keys) {
    return function(val, key, obj__$1) {
      return keys.push(key);
    };
  })(G__9889_9891, keys);
  goog.object.forEach(G__9889_9891, G__9890_9892);
  return keys;
};
cljs.core.js_delete = function cljs$core$js_delete(obj, key) {
  return delete obj[key];
};
cljs.core.array_copy = function cljs$core$array_copy(from, i, to, j, len) {
  var i__$1 = i;
  var j__$1 = j;
  var len__$1 = len;
  while (true) {
    if (len__$1 === 0)
      return to;
    else {
      to[j__$1] = from[i__$1];
      var G__9893 = i__$1 + 1;
      var G__9894 = j__$1 + 1;
      var G__9895 = len__$1 - 1;
      i__$1 = G__9893;
      j__$1 = G__9894;
      len__$1 = G__9895;
      continue;
    }
    break;
  }
};
cljs.core.array_copy_downward = function cljs$core$array_copy_downward(
  from,
  i,
  to,
  j,
  len
) {
  var i__$1 = i + (len - 1);
  var j__$1 = j + (len - 1);
  var len__$1 = len;
  while (true) {
    if (len__$1 === 0)
      return to;
    else {
      to[j__$1] = from[i__$1];
      var G__9896 = i__$1 - 1;
      var G__9897 = j__$1 - 1;
      var G__9898 = len__$1 - 1;
      i__$1 = G__9896;
      j__$1 = G__9897;
      len__$1 = G__9898;
      continue;
    }
    break;
  }
};
cljs.core.lookup_sentinel = {};
cljs.core.false_QMARK_ = function cljs$core$false_QMARK_(x) {
  return x === false;
};
cljs.core.true_QMARK_ = function cljs$core$true_QMARK_(x) {
  return x === true;
};
cljs.core.boolean_QMARK_ = function cljs$core$boolean_QMARK_(x) {
  return x === true || x === false;
};
cljs.core.undefined_QMARK_ = function cljs$core$undefined_QMARK_(x) {
  return void 0 === x;
};
cljs.core.seq_QMARK_ = function cljs$core$seq_QMARK_(s) {
  if (s == null) return false;
  else if (!(s == null))
    if (
      s.cljs$lang$protocol_mask$partition0$ & 64 ||
      cljs.core.PROTOCOL_SENTINEL === s.cljs$core$ISeq$
    )
      return true;
    else if (!s.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.ISeq, s);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.ISeq, s);
};
cljs.core.seqable_QMARK_ = function cljs$core$seqable_QMARK_(s) {
  var or__7144__auto__ = !(s == null)
    ? s.cljs$lang$protocol_mask$partition0$ & 8388608 ||
        cljs.core.PROTOCOL_SENTINEL === s.cljs$core$ISeqable$
        ? true
        : !s.cljs$lang$protocol_mask$partition0$
            ? cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable, s)
            : false
    : cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable, s);
  if (or__7144__auto__) return or__7144__auto__;
  else return cljs.core.array_QMARK_(s) || typeof s === 'string';
};
cljs.core.boolean$ = function cljs$core$boolean(x) {
  if (x == null) return false;
  else if (x === false) return false;
  else return true;
};
cljs.core.ifn_QMARK_ = function cljs$core$ifn_QMARK_(f) {
  var or__7144__auto__ = cljs.core.fn_QMARK_(f);
  if (or__7144__auto__) return or__7144__auto__;
  else if (!(f == null))
    if (
      f.cljs$lang$protocol_mask$partition0$ & 1 ||
      cljs.core.PROTOCOL_SENTINEL === f.cljs$core$IFn$
    )
      return true;
    else if (!f.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IFn, f);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IFn, f);
};
cljs.core.integer_QMARK_ = function cljs$core$integer_QMARK_(n) {
  return typeof n === 'number' &&
    !isNaN(n) &&
    !(n === Infinity) &&
    parseFloat(n) === parseInt(n, 10);
};
cljs.core.int_QMARK_ = function cljs$core$int_QMARK_(x) {
  return cljs.core.integer_QMARK_(x) ||
    x instanceof goog.math.Integer ||
    x instanceof goog.math.Long;
};
cljs.core.pos_int_QMARK_ = function cljs$core$pos_int_QMARK_(x) {
  if (cljs.core.integer_QMARK_(x)) return x > 0;
  else if (x instanceof goog.math.Integer)
    return cljs.core.not(x.isNegative()) && cljs.core.not(x.isZero());
  else if (x instanceof goog.math.Long)
    return cljs.core.not(x.isNegative()) && cljs.core.not(x.isZero());
  else
    return false;
};
cljs.core.neg_int_QMARK_ = function cljs$core$neg_int_QMARK_(x) {
  if (cljs.core.integer_QMARK_(x)) return x < 0;
  else if (x instanceof goog.math.Integer) return x.isNegative();
  else if (x instanceof goog.math.Long) return x.isNegative();
  else return false;
};
cljs.core.nat_int_QMARK_ = function cljs$core$nat_int_QMARK_(x) {
  if (cljs.core.integer_QMARK_(x))
    return !(x < 0) || x === 0;
  else if (x instanceof goog.math.Integer) {
    var or__7144__auto__ = cljs.core.not(x.isNegative());
    if (or__7144__auto__) return or__7144__auto__;
    else return x.isZero();
  } else if (x instanceof goog.math.Long) {
    var or__7144__auto__ = cljs.core.not(x.isNegative());
    if (or__7144__auto__) return or__7144__auto__;
    else return x.isZero();
  } else
    return false;
};
cljs.core.float_QMARK_ = function cljs$core$float_QMARK_(x) {
  return typeof x === 'number';
};
cljs.core.double_QMARK_ = function cljs$core$double_QMARK_(x) {
  return typeof x === 'number';
};
cljs.core.infinite_QMARK_ = function cljs$core$infinite_QMARK_(x) {
  return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
};
cljs.core.contains_QMARK_ = function cljs$core$contains_QMARK_(coll, v) {
  if (
    cljs.core.get.cljs$core$IFn$_invoke$arity$3(
      coll,
      v,
      cljs.core.lookup_sentinel
    ) === cljs.core.lookup_sentinel
  )
    return false;
  else
    return true;
};
cljs.core.find = function cljs$core$find(coll, k) {
  if (
    !(coll == null) &&
    cljs.core.associative_QMARK_(coll) &&
    cljs.core.contains_QMARK_(coll, k)
  )
    return new cljs.core.PersistentVector(
      null,
      2,
      5,
      cljs.core.PersistentVector.EMPTY_NODE,
      [k, cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll, k)],
      null
    );
  else
    return null;
};
cljs.core.distinct_QMARK_ = function cljs$core$distinct_QMARK_(var_args) {
  var args9911 = [];
  var len__8257__auto___9917 = arguments.length;
  var i__8258__auto___9918 = 0;
  while (true) {
    if (i__8258__auto___9918 < len__8257__auto___9917) {
      args9911.push(arguments[i__8258__auto___9918]);
      var G__9919 = i__8258__auto___9918 + 1;
      i__8258__auto___9918 = G__9919;
      continue;
    } else;
    break;
  }
  var G__9916 = args9911.length;
  switch (G__9916) {
    case 1:
      return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9911.slice(2),
        0,
        null
      );
      return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return !cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x, y);
};
cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  if (!cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x, y)) {
    var s = cljs.core.PersistentHashSet.createAsIfByAssoc([x, y], true);
    var xs = more;
    while (true) {
      var x__$1 = cljs.core.first(xs);
      var etc = cljs.core.next(xs);
      if (cljs.core.truth_(xs))
        if (cljs.core.contains_QMARK_(s, x__$1))
          return false;
        else {
          var G__9921 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(s, x__$1);
          var G__9922 = etc;
          s = G__9921;
          xs = G__9922;
          continue;
        }
      else
        return true;
      break;
    }
  } else
    return false;
};
cljs.core.distinct_QMARK_.cljs$lang$applyTo = function(seq9912) {
  var G__9913 = cljs.core.first(seq9912);
  var seq9912__$1 = cljs.core.next(seq9912);
  var G__9914 = cljs.core.first(seq9912__$1);
  var seq9912__$2 = cljs.core.next(seq9912__$1);
  return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic(
    G__9913,
    G__9914,
    seq9912__$2
  );
};
cljs.core.distinct_QMARK_.cljs$lang$maxFixedArity = 2;
cljs.core.compare = function cljs$core$compare(x, y) {
  if (x === y) return 0;
  else if (x == null) return -1;
  else if (y == null) return 1;
  else if (typeof x === 'number')
    if (typeof y === 'number') return goog.array.defaultCompare(x, y);
    else throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Cannot compare '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(x),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(' to '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)
        ].join('')
      );
  else if (
    !(x == null)
      ? x.cljs$lang$protocol_mask$partition1$ & 2048 ||
          cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IComparable$
          ? true
          : !x.cljs$lang$protocol_mask$partition1$
              ? cljs.core.native_satisfies_QMARK_(cljs.core.IComparable, x)
              : false
      : cljs.core.native_satisfies_QMARK_(cljs.core.IComparable, x)
  )
    return cljs.core._compare(x, y);
  else if (
    (typeof x === 'string' ||
      cljs.core.array_QMARK_(x) ||
      x === true ||
      x === false) &&
    cljs.core.type(x) === cljs.core.type(y)
  )
    return goog.array.defaultCompare(x, y);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1('Cannot compare '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(x),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(' to '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)
      ].join('')
    );
};
cljs.core.compare_indexed = function cljs$core$compare_indexed(var_args) {
  var args9925 = [];
  var len__8257__auto___9928 = arguments.length;
  var i__8258__auto___9929 = 0;
  while (true) {
    if (i__8258__auto___9929 < len__8257__auto___9928) {
      args9925.push(arguments[i__8258__auto___9929]);
      var G__9930 = i__8258__auto___9929 + 1;
      i__8258__auto___9929 = G__9930;
      continue;
    } else;
    break;
  }
  var G__9927 = args9925.length;
  switch (G__9927) {
    case 2:
      return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 4:
      return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9925.length)
        ].join('')
      );
  }
};
cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2 = function(xs, ys) {
  var xl = cljs.core.count(xs);
  var yl = cljs.core.count(ys);
  if (xl < yl) return -1;
  else if (xl > yl) return 1;
  else if (xl === 0) return 0;
  else return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4(
      xs,
      ys,
      xl,
      0
    );
};
cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4 = function(
  xs,
  ys,
  len,
  n
) {
  while (true) {
    var d = cljs.core.compare(
      cljs.core.nth.cljs$core$IFn$_invoke$arity$2(xs, n),
      cljs.core.nth.cljs$core$IFn$_invoke$arity$2(ys, n)
    );
    if (d === 0 && n + 1 < len) {
      var G__9932 = xs;
      var G__9933 = ys;
      var G__9934 = len;
      var G__9935 = n + 1;
      xs = G__9932;
      ys = G__9933;
      len = G__9934;
      n = G__9935;
      continue;
    } else
      return d;
    break;
  }
};
cljs.core.compare_indexed.cljs$lang$maxFixedArity = 4;
cljs.core.fn__GT_comparator = function cljs$core$fn__GT_comparator(f) {
  if (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(f, cljs.core.compare))
    return cljs.core.compare;
  else
    return function(x, y) {
      var r = f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(x, y)
        : f.call(null, x, y);
      if (typeof r === 'number') return r;
      else if (cljs.core.truth_(r)) return -1;
      else if (
        cljs.core.truth_(
          f.cljs$core$IFn$_invoke$arity$2
            ? f.cljs$core$IFn$_invoke$arity$2(y, x)
            : f.call(null, y, x)
        )
      )
        return 1;
      else
        return 0;
    };
};
cljs.core.sort = function cljs$core$sort(var_args) {
  var args9936 = [];
  var len__8257__auto___9941 = arguments.length;
  var i__8258__auto___9942 = 0;
  while (true) {
    if (i__8258__auto___9942 < len__8257__auto___9941) {
      args9936.push(arguments[i__8258__auto___9942]);
      var G__9943 = i__8258__auto___9942 + 1;
      i__8258__auto___9942 = G__9943;
      continue;
    } else;
    break;
  }
  var G__9938 = args9936.length;
  switch (G__9938) {
    case 1:
      return cljs.core.sort.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.sort.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9936.length)
        ].join('')
      );
  }
};
cljs.core.sort.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  return cljs.core.sort.cljs$core$IFn$_invoke$arity$2(cljs.core.compare, coll);
};
cljs.core.sort.cljs$core$IFn$_invoke$arity$2 = function(comp, coll) {
  if (cljs.core.seq(coll)) {
    var a = cljs.core.to_array.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.to_array.cljs$core$IFn$_invoke$arity$1(coll)
      : cljs.core.to_array.call(null, coll);
    var G__9939_9945 = a;
    var G__9940_9946 = cljs.core.fn__GT_comparator(comp);
    goog.array.stableSort(G__9939_9945, G__9940_9946);
    return cljs.core.seq(a);
  } else
    return cljs.core.List.EMPTY;
};
cljs.core.sort.cljs$lang$maxFixedArity = 2;
cljs.core.sort_by = function cljs$core$sort_by(var_args) {
  var args9947 = [];
  var len__8257__auto___9950 = arguments.length;
  var i__8258__auto___9951 = 0;
  while (true) {
    if (i__8258__auto___9951 < len__8257__auto___9950) {
      args9947.push(arguments[i__8258__auto___9951]);
      var G__9952 = i__8258__auto___9951 + 1;
      i__8258__auto___9951 = G__9952;
      continue;
    } else;
    break;
  }
  var G__9949 = args9947.length;
  switch (G__9949) {
    case 2:
      return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9947.length)
        ].join('')
      );
  }
};
cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2 = function(keyfn, coll) {
  return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3(
    keyfn,
    cljs.core.compare,
    coll
  );
};
cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3 = function(keyfn, comp, coll) {
  return cljs.core.sort.cljs$core$IFn$_invoke$arity$2(
    function(x, y) {
      return cljs.core
        .fn__GT_comparator(comp)
        .call(
          null,
          keyfn.cljs$core$IFn$_invoke$arity$1
            ? keyfn.cljs$core$IFn$_invoke$arity$1(x)
            : keyfn.call(null, x),
          keyfn.cljs$core$IFn$_invoke$arity$1
            ? keyfn.cljs$core$IFn$_invoke$arity$1(y)
            : keyfn.call(null, y)
        );
    },
    coll
  );
};
cljs.core.sort_by.cljs$lang$maxFixedArity = 3;
cljs.core.seq_reduce = function cljs$core$seq_reduce(var_args) {
  var args9954 = [];
  var len__8257__auto___9962 = arguments.length;
  var i__8258__auto___9963 = 0;
  while (true) {
    if (i__8258__auto___9963 < len__8257__auto___9962) {
      args9954.push(arguments[i__8258__auto___9963]);
      var G__9964 = i__8258__auto___9963 + 1;
      i__8258__auto___9963 = G__9964;
      continue;
    } else;
    break;
  }
  var G__9956 = args9954.length;
  switch (G__9956) {
    case 2:
      return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9954.length)
        ].join('')
      );
  }
};
cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  var temp__4655__auto__ = cljs.core.seq(coll);
  if (temp__4655__auto__) {
    var s = temp__4655__auto__;
    var G__9957 = f;
    var G__9958 = cljs.core.first(s);
    var G__9959 = cljs.core.next(s);
    return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3
      ? cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
          G__9957,
          G__9958,
          G__9959
        )
      : cljs.core.reduce.call(null, G__9957, G__9958, G__9959);
  } else
    return f.cljs$core$IFn$_invoke$arity$0
      ? f.cljs$core$IFn$_invoke$arity$0()
      : f.call(null);
};
cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3 = function(f, val, coll) {
  var val__$1 = val;
  var coll__$1 = cljs.core.seq(coll);
  while (true) {
    if (coll__$1) {
      var nval = (function() {
        var G__9960 = val__$1;
        var G__9961 = cljs.core.first(coll__$1);
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__9960, G__9961)
          : f.call(null, G__9960, G__9961);
      })();
      if (cljs.core.reduced_QMARK_(nval))
        return cljs.core.deref(nval);
      else {
        var G__9966 = nval;
        var G__9967 = cljs.core.next(coll__$1);
        val__$1 = G__9966;
        coll__$1 = G__9967;
        continue;
      }
    } else
      return val__$1;
    break;
  }
};
cljs.core.seq_reduce.cljs$lang$maxFixedArity = 3;
cljs.core.shuffle = function cljs$core$shuffle(coll) {
  var a = cljs.core.to_array.cljs$core$IFn$_invoke$arity$1
    ? cljs.core.to_array.cljs$core$IFn$_invoke$arity$1(coll)
    : cljs.core.to_array.call(null, coll);
  goog.array.shuffle(a);
  return cljs.core.vec.cljs$core$IFn$_invoke$arity$1
    ? cljs.core.vec.cljs$core$IFn$_invoke$arity$1(a)
    : cljs.core.vec.call(null, a);
};
cljs.core.reduce = function cljs$core$reduce(var_args) {
  var args9968 = [];
  var len__8257__auto___9973 = arguments.length;
  var i__8258__auto___9974 = 0;
  while (true) {
    if (i__8258__auto___9974 < len__8257__auto___9973) {
      args9968.push(arguments[i__8258__auto___9974]);
      var G__9975 = i__8258__auto___9974 + 1;
      i__8258__auto___9974 = G__9975;
      continue;
    } else;
    break;
  }
  var G__9970 = args9968.length;
  switch (G__9970) {
    case 2:
      return cljs.core.reduce.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9968.length)
        ].join('')
      );
  }
};
cljs.core.reduce.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 524288 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReduce$
          ? true
          : false
      : false
  )
    return coll.cljs$core$IReduce$_reduce$arity$2(null, f);
  else if (cljs.core.array_QMARK_(coll))
    return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll, f);
  else if (typeof coll === 'string')
    return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll, f);
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.IReduce, coll))
    return cljs.core._reduce.cljs$core$IFn$_invoke$arity$2(coll, f);
  else
    return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, coll);
};
cljs.core.reduce.cljs$core$IFn$_invoke$arity$3 = function(f, val, coll) {
  if (
    !(coll == null)
      ? coll.cljs$lang$protocol_mask$partition0$ & 524288 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReduce$
          ? true
          : false
      : false
  )
    return coll.cljs$core$IReduce$_reduce$arity$3(null, f, val);
  else if (cljs.core.array_QMARK_(coll))
    return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll, f, val);
  else if (typeof coll === 'string')
    return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll, f, val);
  else if (cljs.core.native_satisfies_QMARK_(cljs.core.IReduce, coll))
    return cljs.core._reduce.cljs$core$IFn$_invoke$arity$3(coll, f, val);
  else
    return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, val, coll);
};
cljs.core.reduce.cljs$lang$maxFixedArity = 3;
cljs.core.reduce_kv = function cljs$core$reduce_kv(f, init, coll) {
  if (!(coll == null)) return cljs.core._kv_reduce(coll, f, init);
  else return init;
};
cljs.core.identity = function cljs$core$identity(x) {
  return x;
};
cljs.core.completing = function cljs$core$completing(var_args) {
  var args9977 = [];
  var len__8257__auto___9980 = arguments.length;
  var i__8258__auto___9981 = 0;
  while (true) {
    if (i__8258__auto___9981 < len__8257__auto___9980) {
      args9977.push(arguments[i__8258__auto___9981]);
      var G__9982 = i__8258__auto___9981 + 1;
      i__8258__auto___9981 = G__9982;
      continue;
    } else;
    break;
  }
  var G__9979 = args9977.length;
  switch (G__9979) {
    case 1:
      return cljs.core.completing.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.completing.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9977.length)
        ].join('')
      );
  }
};
cljs.core.completing.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return cljs.core.completing.cljs$core$IFn$_invoke$arity$2(
    f,
    cljs.core.identity
  );
};
cljs.core.completing.cljs$core$IFn$_invoke$arity$2 = function(f, cf) {
  return (function() {
    var G__9984 = null;
    var G__9984__0 = function() {
      return f.cljs$core$IFn$_invoke$arity$0
        ? f.cljs$core$IFn$_invoke$arity$0()
        : f.call(null);
    };
    var G__9984__1 = function(x) {
      return cf.cljs$core$IFn$_invoke$arity$1
        ? cf.cljs$core$IFn$_invoke$arity$1(x)
        : cf.call(null, x);
    };
    var G__9984__2 = function(x, y) {
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(x, y)
        : f.call(null, x, y);
    };
    G__9984 = function(x, y) {
      switch (arguments.length) {
        case 0:
          return G__9984__0.call(this);
        case 1:
          return G__9984__1.call(this, x);
        case 2:
          return G__9984__2.call(this, x, y);
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__9984.cljs$core$IFn$_invoke$arity$0 = G__9984__0;
    G__9984.cljs$core$IFn$_invoke$arity$1 = G__9984__1;
    G__9984.cljs$core$IFn$_invoke$arity$2 = G__9984__2;
    return G__9984;
  })();
};
cljs.core.completing.cljs$lang$maxFixedArity = 2;
cljs.core.transduce = function cljs$core$transduce(var_args) {
  var args9985 = [];
  var len__8257__auto___9988 = arguments.length;
  var i__8258__auto___9989 = 0;
  while (true) {
    if (i__8258__auto___9989 < len__8257__auto___9988) {
      args9985.push(arguments[i__8258__auto___9989]);
      var G__9990 = i__8258__auto___9989 + 1;
      i__8258__auto___9989 = G__9990;
      continue;
    } else;
    break;
  }
  var G__9987 = args9985.length;
  switch (G__9987) {
    case 3:
      return cljs.core.transduce.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args9985.length)
        ].join('')
      );
  }
};
cljs.core.transduce.cljs$core$IFn$_invoke$arity$3 = function(xform, f, coll) {
  return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(
    xform,
    f,
    f.cljs$core$IFn$_invoke$arity$0
      ? f.cljs$core$IFn$_invoke$arity$0()
      : f.call(null),
    coll
  );
};
cljs.core.transduce.cljs$core$IFn$_invoke$arity$4 = function(
  xform,
  f,
  init,
  coll
) {
  var f__$1 = xform.cljs$core$IFn$_invoke$arity$1
    ? xform.cljs$core$IFn$_invoke$arity$1(f)
    : xform.call(null, f);
  var ret = cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(f__$1, init, coll);
  return f__$1.cljs$core$IFn$_invoke$arity$1
    ? f__$1.cljs$core$IFn$_invoke$arity$1(ret)
    : f__$1.call(null, ret);
};
cljs.core.transduce.cljs$lang$maxFixedArity = 4;
cljs.core._PLUS_ = function cljs$core$_PLUS_(var_args) {
  var args9992 = [];
  var len__8257__auto___9998 = arguments.length;
  var i__8258__auto___9999 = 0;
  while (true) {
    if (i__8258__auto___9999 < len__8257__auto___9998) {
      args9992.push(arguments[i__8258__auto___9999]);
      var G__10000 = i__8258__auto___9999 + 1;
      i__8258__auto___9999 = G__10000;
      continue;
    } else;
    break;
  }
  var G__9997 = args9992.length;
  switch (G__9997) {
    case 0:
      return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args9992.slice(2),
        0,
        null
      );
      return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0 = function() {
  return 0;
};
cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x + y;
};
cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core._PLUS_,
    x + y,
    more
  );
};
cljs.core._PLUS_.cljs$lang$applyTo = function(seq9993) {
  var G__9994 = cljs.core.first(seq9993);
  var seq9993__$1 = cljs.core.next(seq9993);
  var G__9995 = cljs.core.first(seq9993__$1);
  var seq9993__$2 = cljs.core.next(seq9993__$1);
  return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic(
    G__9994,
    G__9995,
    seq9993__$2
  );
};
cljs.core._PLUS_.cljs$lang$maxFixedArity = 2;
cljs.core._ = function cljs$core$_(var_args) {
  var args10002 = [];
  var len__8257__auto___10008 = arguments.length;
  var i__8258__auto___10009 = 0;
  while (true) {
    if (i__8258__auto___10009 < len__8257__auto___10008) {
      args10002.push(arguments[i__8258__auto___10009]);
      var G__10010 = i__8258__auto___10009 + 1;
      i__8258__auto___10009 = G__10010;
      continue;
    } else;
    break;
  }
  var G__10007 = args10002.length;
  switch (G__10007) {
    case 1:
      return cljs.core._.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10002.slice(2),
        0,
        null
      );
      return cljs.core._.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return -x;
};
cljs.core._.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x - y;
};
cljs.core._.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core._,
    x - y,
    more
  );
};
cljs.core._.cljs$lang$applyTo = function(seq10003) {
  var G__10004 = cljs.core.first(seq10003);
  var seq10003__$1 = cljs.core.next(seq10003);
  var G__10005 = cljs.core.first(seq10003__$1);
  var seq10003__$2 = cljs.core.next(seq10003__$1);
  return cljs.core._.cljs$core$IFn$_invoke$arity$variadic(
    G__10004,
    G__10005,
    seq10003__$2
  );
};
cljs.core._.cljs$lang$maxFixedArity = 2;
cljs.core._STAR_ = function cljs$core$_STAR_(var_args) {
  var args10012 = [];
  var len__8257__auto___10018 = arguments.length;
  var i__8258__auto___10019 = 0;
  while (true) {
    if (i__8258__auto___10019 < len__8257__auto___10018) {
      args10012.push(arguments[i__8258__auto___10019]);
      var G__10020 = i__8258__auto___10019 + 1;
      i__8258__auto___10019 = G__10020;
      continue;
    } else;
    break;
  }
  var G__10017 = args10012.length;
  switch (G__10017) {
    case 0:
      return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10012.slice(2),
        0,
        null
      );
      return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0 = function() {
  return 1;
};
cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x * y;
};
cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core._STAR_,
    x * y,
    more
  );
};
cljs.core._STAR_.cljs$lang$applyTo = function(seq10013) {
  var G__10014 = cljs.core.first(seq10013);
  var seq10013__$1 = cljs.core.next(seq10013);
  var G__10015 = cljs.core.first(seq10013__$1);
  var seq10013__$2 = cljs.core.next(seq10013__$1);
  return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic(
    G__10014,
    G__10015,
    seq10013__$2
  );
};
cljs.core._STAR_.cljs$lang$maxFixedArity = 2;
cljs.core._SLASH_ = function cljs$core$_SLASH_(var_args) {
  var args10022 = [];
  var len__8257__auto___10028 = arguments.length;
  var i__8258__auto___10029 = 0;
  while (true) {
    if (i__8258__auto___10029 < len__8257__auto___10028) {
      args10022.push(arguments[i__8258__auto___10029]);
      var G__10030 = i__8258__auto___10029 + 1;
      i__8258__auto___10029 = G__10030;
      continue;
    } else;
    break;
  }
  var G__10027 = args10022.length;
  switch (G__10027) {
    case 1:
      return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10022.slice(2),
        0,
        null
      );
      return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return 1 / x;
};
cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x / y;
};
cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core._SLASH_,
    x / y,
    more
  );
};
cljs.core._SLASH_.cljs$lang$applyTo = function(seq10023) {
  var G__10024 = cljs.core.first(seq10023);
  var seq10023__$1 = cljs.core.next(seq10023);
  var G__10025 = cljs.core.first(seq10023__$1);
  var seq10023__$2 = cljs.core.next(seq10023__$1);
  return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic(
    G__10024,
    G__10025,
    seq10023__$2
  );
};
cljs.core._SLASH_.cljs$lang$maxFixedArity = 2;
cljs.core._LT_ = function cljs$core$_LT_(var_args) {
  var args10032 = [];
  var len__8257__auto___10038 = arguments.length;
  var i__8258__auto___10039 = 0;
  while (true) {
    if (i__8258__auto___10039 < len__8257__auto___10038) {
      args10032.push(arguments[i__8258__auto___10039]);
      var G__10040 = i__8258__auto___10039 + 1;
      i__8258__auto___10039 = G__10040;
      continue;
    } else;
    break;
  }
  var G__10037 = args10032.length;
  switch (G__10037) {
    case 1:
      return cljs.core._LT_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._LT_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10032.slice(2),
        0,
        null
      );
      return cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._LT_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._LT_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x < y;
};
cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (x < y)
      if (cljs.core.next(more)) {
        var G__10042 = y;
        var G__10043 = cljs.core.first(more);
        var G__10044 = cljs.core.next(more);
        x = G__10042;
        y = G__10043;
        more = G__10044;
        continue;
      } else
        return y < cljs.core.first(more);
    else
      return false;
    break;
  }
};
cljs.core._LT_.cljs$lang$applyTo = function(seq10033) {
  var G__10034 = cljs.core.first(seq10033);
  var seq10033__$1 = cljs.core.next(seq10033);
  var G__10035 = cljs.core.first(seq10033__$1);
  var seq10033__$2 = cljs.core.next(seq10033__$1);
  return cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic(
    G__10034,
    G__10035,
    seq10033__$2
  );
};
cljs.core._LT_.cljs$lang$maxFixedArity = 2;
cljs.core._LT__EQ_ = function cljs$core$_LT__EQ_(var_args) {
  var args10045 = [];
  var len__8257__auto___10051 = arguments.length;
  var i__8258__auto___10052 = 0;
  while (true) {
    if (i__8258__auto___10052 < len__8257__auto___10051) {
      args10045.push(arguments[i__8258__auto___10052]);
      var G__10053 = i__8258__auto___10052 + 1;
      i__8258__auto___10052 = G__10053;
      continue;
    } else;
    break;
  }
  var G__10050 = args10045.length;
  switch (G__10050) {
    case 1:
      return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10045.slice(2),
        0,
        null
      );
      return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x <= y;
};
cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (x <= y)
      if (cljs.core.next(more)) {
        var G__10055 = y;
        var G__10056 = cljs.core.first(more);
        var G__10057 = cljs.core.next(more);
        x = G__10055;
        y = G__10056;
        more = G__10057;
        continue;
      } else
        return y <= cljs.core.first(more);
    else
      return false;
    break;
  }
};
cljs.core._LT__EQ_.cljs$lang$applyTo = function(seq10046) {
  var G__10047 = cljs.core.first(seq10046);
  var seq10046__$1 = cljs.core.next(seq10046);
  var G__10048 = cljs.core.first(seq10046__$1);
  var seq10046__$2 = cljs.core.next(seq10046__$1);
  return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic(
    G__10047,
    G__10048,
    seq10046__$2
  );
};
cljs.core._LT__EQ_.cljs$lang$maxFixedArity = 2;
cljs.core._GT_ = function cljs$core$_GT_(var_args) {
  var args10058 = [];
  var len__8257__auto___10064 = arguments.length;
  var i__8258__auto___10065 = 0;
  while (true) {
    if (i__8258__auto___10065 < len__8257__auto___10064) {
      args10058.push(arguments[i__8258__auto___10065]);
      var G__10066 = i__8258__auto___10065 + 1;
      i__8258__auto___10065 = G__10066;
      continue;
    } else;
    break;
  }
  var G__10063 = args10058.length;
  switch (G__10063) {
    case 1:
      return cljs.core._GT_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._GT_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10058.slice(2),
        0,
        null
      );
      return cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._GT_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._GT_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x > y;
};
cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (x > y)
      if (cljs.core.next(more)) {
        var G__10068 = y;
        var G__10069 = cljs.core.first(more);
        var G__10070 = cljs.core.next(more);
        x = G__10068;
        y = G__10069;
        more = G__10070;
        continue;
      } else
        return y > cljs.core.first(more);
    else
      return false;
    break;
  }
};
cljs.core._GT_.cljs$lang$applyTo = function(seq10059) {
  var G__10060 = cljs.core.first(seq10059);
  var seq10059__$1 = cljs.core.next(seq10059);
  var G__10061 = cljs.core.first(seq10059__$1);
  var seq10059__$2 = cljs.core.next(seq10059__$1);
  return cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic(
    G__10060,
    G__10061,
    seq10059__$2
  );
};
cljs.core._GT_.cljs$lang$maxFixedArity = 2;
cljs.core._GT__EQ_ = function cljs$core$_GT__EQ_(var_args) {
  var args10071 = [];
  var len__8257__auto___10077 = arguments.length;
  var i__8258__auto___10078 = 0;
  while (true) {
    if (i__8258__auto___10078 < len__8257__auto___10077) {
      args10071.push(arguments[i__8258__auto___10078]);
      var G__10079 = i__8258__auto___10078 + 1;
      i__8258__auto___10078 = G__10079;
      continue;
    } else;
    break;
  }
  var G__10076 = args10071.length;
  switch (G__10076) {
    case 1:
      return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10071.slice(2),
        0,
        null
      );
      return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x >= y;
};
cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (x >= y)
      if (cljs.core.next(more)) {
        var G__10081 = y;
        var G__10082 = cljs.core.first(more);
        var G__10083 = cljs.core.next(more);
        x = G__10081;
        y = G__10082;
        more = G__10083;
        continue;
      } else
        return y >= cljs.core.first(more);
    else
      return false;
    break;
  }
};
cljs.core._GT__EQ_.cljs$lang$applyTo = function(seq10072) {
  var G__10073 = cljs.core.first(seq10072);
  var seq10072__$1 = cljs.core.next(seq10072);
  var G__10074 = cljs.core.first(seq10072__$1);
  var seq10072__$2 = cljs.core.next(seq10072__$1);
  return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic(
    G__10073,
    G__10074,
    seq10072__$2
  );
};
cljs.core._GT__EQ_.cljs$lang$maxFixedArity = 2;
cljs.core.dec = function cljs$core$dec(x) {
  return x - 1;
};
cljs.core.max = function cljs$core$max(var_args) {
  var args10084 = [];
  var len__8257__auto___10090 = arguments.length;
  var i__8258__auto___10091 = 0;
  while (true) {
    if (i__8258__auto___10091 < len__8257__auto___10090) {
      args10084.push(arguments[i__8258__auto___10091]);
      var G__10092 = i__8258__auto___10091 + 1;
      i__8258__auto___10091 = G__10092;
      continue;
    } else;
    break;
  }
  var G__10089 = args10084.length;
  switch (G__10089) {
    case 1:
      return cljs.core.max.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.max.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10084.slice(2),
        0,
        null
      );
      return cljs.core.max.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.max.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.max.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  var x__7480__auto__ = x;
  var y__7481__auto__ = y;
  return x__7480__auto__ > y__7481__auto__ ? x__7480__auto__ : y__7481__auto__;
};
cljs.core.max.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.max,
    (function() {
      var x__7480__auto__ = x;
      var y__7481__auto__ = y;
      return x__7480__auto__ > y__7481__auto__
        ? x__7480__auto__
        : y__7481__auto__;
    })(),
    more
  );
};
cljs.core.max.cljs$lang$applyTo = function(seq10085) {
  var G__10086 = cljs.core.first(seq10085);
  var seq10085__$1 = cljs.core.next(seq10085);
  var G__10087 = cljs.core.first(seq10085__$1);
  var seq10085__$2 = cljs.core.next(seq10085__$1);
  return cljs.core.max.cljs$core$IFn$_invoke$arity$variadic(
    G__10086,
    G__10087,
    seq10085__$2
  );
};
cljs.core.max.cljs$lang$maxFixedArity = 2;
cljs.core.min = function cljs$core$min(var_args) {
  var args10094 = [];
  var len__8257__auto___10100 = arguments.length;
  var i__8258__auto___10101 = 0;
  while (true) {
    if (i__8258__auto___10101 < len__8257__auto___10100) {
      args10094.push(arguments[i__8258__auto___10101]);
      var G__10102 = i__8258__auto___10101 + 1;
      i__8258__auto___10101 = G__10102;
      continue;
    } else;
    break;
  }
  var G__10099 = args10094.length;
  switch (G__10099) {
    case 1:
      return cljs.core.min.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.min.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10094.slice(2),
        0,
        null
      );
      return cljs.core.min.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.min.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.min.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  var x__7487__auto__ = x;
  var y__7488__auto__ = y;
  return x__7487__auto__ < y__7488__auto__ ? x__7487__auto__ : y__7488__auto__;
};
cljs.core.min.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.min,
    (function() {
      var x__7487__auto__ = x;
      var y__7488__auto__ = y;
      return x__7487__auto__ < y__7488__auto__
        ? x__7487__auto__
        : y__7488__auto__;
    })(),
    more
  );
};
cljs.core.min.cljs$lang$applyTo = function(seq10095) {
  var G__10096 = cljs.core.first(seq10095);
  var seq10095__$1 = cljs.core.next(seq10095);
  var G__10097 = cljs.core.first(seq10095__$1);
  var seq10095__$2 = cljs.core.next(seq10095__$1);
  return cljs.core.min.cljs$core$IFn$_invoke$arity$variadic(
    G__10096,
    G__10097,
    seq10095__$2
  );
};
cljs.core.min.cljs$lang$maxFixedArity = 2;
cljs.core.byte$ = function cljs$core$byte(x) {
  return x;
};
cljs.core.char$ = function cljs$core$char(x) {
  if (typeof x === 'number') return String.fromCharCode(x);
  else if (typeof x === 'string' && x.length === 1) return x;
  else throw new Error('Argument to char must be a character or number');
};
cljs.core.short$ = function cljs$core$short(x) {
  return x;
};
cljs.core.float$ = function cljs$core$float(x) {
  return x;
};
cljs.core.double$ = function cljs$core$double(x) {
  return x;
};
cljs.core.unchecked_byte = function cljs$core$unchecked_byte(x) {
  return x;
};
cljs.core.unchecked_char = function cljs$core$unchecked_char(x) {
  return x;
};
cljs.core.unchecked_short = function cljs$core$unchecked_short(x) {
  return x;
};
cljs.core.unchecked_float = function cljs$core$unchecked_float(x) {
  return x;
};
cljs.core.unchecked_double = function cljs$core$unchecked_double(x) {
  return x;
};
cljs.core.unchecked_add = function cljs$core$unchecked_add(var_args) {
  var args10104 = [];
  var len__8257__auto___10110 = arguments.length;
  var i__8258__auto___10111 = 0;
  while (true) {
    if (i__8258__auto___10111 < len__8257__auto___10110) {
      args10104.push(arguments[i__8258__auto___10111]);
      var G__10112 = i__8258__auto___10111 + 1;
      i__8258__auto___10111 = G__10112;
      continue;
    } else;
    break;
  }
  var G__10109 = args10104.length;
  switch (G__10109) {
    case 0:
      return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10104.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0 = function() {
  return 0;
};
cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x + y;
};
cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_add,
    x + y,
    more
  );
};
cljs.core.unchecked_add.cljs$lang$applyTo = function(seq10105) {
  var G__10106 = cljs.core.first(seq10105);
  var seq10105__$1 = cljs.core.next(seq10105);
  var G__10107 = cljs.core.first(seq10105__$1);
  var seq10105__$2 = cljs.core.next(seq10105__$1);
  return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic(
    G__10106,
    G__10107,
    seq10105__$2
  );
};
cljs.core.unchecked_add.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_add_int = function cljs$core$unchecked_add_int(var_args) {
  var args10114 = [];
  var len__8257__auto___10120 = arguments.length;
  var i__8258__auto___10121 = 0;
  while (true) {
    if (i__8258__auto___10121 < len__8257__auto___10120) {
      args10114.push(arguments[i__8258__auto___10121]);
      var G__10122 = i__8258__auto___10121 + 1;
      i__8258__auto___10121 = G__10122;
      continue;
    } else;
    break;
  }
  var G__10119 = args10114.length;
  switch (G__10119) {
    case 0:
      return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10114.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0 = function() {
  return 0;
};
cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x + y;
};
cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_add_int,
    x + y,
    more
  );
};
cljs.core.unchecked_add_int.cljs$lang$applyTo = function(seq10115) {
  var G__10116 = cljs.core.first(seq10115);
  var seq10115__$1 = cljs.core.next(seq10115);
  var G__10117 = cljs.core.first(seq10115__$1);
  var seq10115__$2 = cljs.core.next(seq10115__$1);
  return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic(
    G__10116,
    G__10117,
    seq10115__$2
  );
};
cljs.core.unchecked_add_int.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_dec = function cljs$core$unchecked_dec(x) {
  return x - 1;
};
cljs.core.unchecked_dec_int = function cljs$core$unchecked_dec_int(x) {
  return x - 1;
};
cljs.core.unchecked_divide_int = function cljs$core$unchecked_divide_int(
  var_args
) {
  var args10124 = [];
  var len__8257__auto___10130 = arguments.length;
  var i__8258__auto___10131 = 0;
  while (true) {
    if (i__8258__auto___10131 < len__8257__auto___10130) {
      args10124.push(arguments[i__8258__auto___10131]);
      var G__10132 = i__8258__auto___10131 + 1;
      i__8258__auto___10131 = G__10132;
      continue;
    } else;
    break;
  }
  var G__10129 = args10124.length;
  switch (G__10129) {
    case 1:
      return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10124.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return 1 / x;
};
cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x / y;
};
cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_divide_int,
    x / y,
    more
  );
};
cljs.core.unchecked_divide_int.cljs$lang$applyTo = function(seq10125) {
  var G__10126 = cljs.core.first(seq10125);
  var seq10125__$1 = cljs.core.next(seq10125);
  var G__10127 = cljs.core.first(seq10125__$1);
  var seq10125__$2 = cljs.core.next(seq10125__$1);
  return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic(
    G__10126,
    G__10127,
    seq10125__$2
  );
};
cljs.core.unchecked_divide_int.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_inc = function cljs$core$unchecked_inc(x) {
  return x + 1;
};
cljs.core.unchecked_inc_int = function cljs$core$unchecked_inc_int(x) {
  return x + 1;
};
cljs.core.unchecked_multiply = function cljs$core$unchecked_multiply(var_args) {
  var args10134 = [];
  var len__8257__auto___10140 = arguments.length;
  var i__8258__auto___10141 = 0;
  while (true) {
    if (i__8258__auto___10141 < len__8257__auto___10140) {
      args10134.push(arguments[i__8258__auto___10141]);
      var G__10142 = i__8258__auto___10141 + 1;
      i__8258__auto___10141 = G__10142;
      continue;
    } else;
    break;
  }
  var G__10139 = args10134.length;
  switch (G__10139) {
    case 0:
      return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10134.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0 = function() {
  return 1;
};
cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x * y;
};
cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_multiply,
    x * y,
    more
  );
};
cljs.core.unchecked_multiply.cljs$lang$applyTo = function(seq10135) {
  var G__10136 = cljs.core.first(seq10135);
  var seq10135__$1 = cljs.core.next(seq10135);
  var G__10137 = cljs.core.first(seq10135__$1);
  var seq10135__$2 = cljs.core.next(seq10135__$1);
  return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic(
    G__10136,
    G__10137,
    seq10135__$2
  );
};
cljs.core.unchecked_multiply.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_multiply_int = function cljs$core$unchecked_multiply_int(
  var_args
) {
  var args10144 = [];
  var len__8257__auto___10150 = arguments.length;
  var i__8258__auto___10151 = 0;
  while (true) {
    if (i__8258__auto___10151 < len__8257__auto___10150) {
      args10144.push(arguments[i__8258__auto___10151]);
      var G__10152 = i__8258__auto___10151 + 1;
      i__8258__auto___10151 = G__10152;
      continue;
    } else;
    break;
  }
  var G__10149 = args10144.length;
  switch (G__10149) {
    case 0:
      return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10144.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0 = function() {
  return 1;
};
cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return x;
};
cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2 = function(
  x,
  y
) {
  return x * y;
};
cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_multiply_int,
    x * y,
    more
  );
};
cljs.core.unchecked_multiply_int.cljs$lang$applyTo = function(seq10145) {
  var G__10146 = cljs.core.first(seq10145);
  var seq10145__$1 = cljs.core.next(seq10145);
  var G__10147 = cljs.core.first(seq10145__$1);
  var seq10145__$2 = cljs.core.next(seq10145__$1);
  return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic(
    G__10146,
    G__10147,
    seq10145__$2
  );
};
cljs.core.unchecked_multiply_int.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_negate = function cljs$core$unchecked_negate(x) {
  return -x;
};
cljs.core.unchecked_negate_int = function cljs$core$unchecked_negate_int(x) {
  return -x;
};
cljs.core.unchecked_remainder_int = function cljs$core$unchecked_remainder_int(
  x,
  n
) {
  return cljs.core.mod.cljs$core$IFn$_invoke$arity$2
    ? cljs.core.mod.cljs$core$IFn$_invoke$arity$2(x, n)
    : cljs.core.mod.call(null, x, n);
};
cljs.core.unchecked_subtract = function cljs$core$unchecked_subtract(var_args) {
  var args10154 = [];
  var len__8257__auto___10160 = arguments.length;
  var i__8258__auto___10161 = 0;
  while (true) {
    if (i__8258__auto___10161 < len__8257__auto___10160) {
      args10154.push(arguments[i__8258__auto___10161]);
      var G__10162 = i__8258__auto___10161 + 1;
      i__8258__auto___10161 = G__10162;
      continue;
    } else;
    break;
  }
  var G__10159 = args10154.length;
  switch (G__10159) {
    case 1:
      return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10154.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return -x;
};
cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x - y;
};
cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_subtract,
    x - y,
    more
  );
};
cljs.core.unchecked_subtract.cljs$lang$applyTo = function(seq10155) {
  var G__10156 = cljs.core.first(seq10155);
  var seq10155__$1 = cljs.core.next(seq10155);
  var G__10157 = cljs.core.first(seq10155__$1);
  var seq10155__$2 = cljs.core.next(seq10155__$1);
  return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic(
    G__10156,
    G__10157,
    seq10155__$2
  );
};
cljs.core.unchecked_subtract.cljs$lang$maxFixedArity = 2;
cljs.core.unchecked_subtract_int = function cljs$core$unchecked_subtract_int(
  var_args
) {
  var args10164 = [];
  var len__8257__auto___10170 = arguments.length;
  var i__8258__auto___10171 = 0;
  while (true) {
    if (i__8258__auto___10171 < len__8257__auto___10170) {
      args10164.push(arguments[i__8258__auto___10171]);
      var G__10172 = i__8258__auto___10171 + 1;
      i__8258__auto___10171 = G__10172;
      continue;
    } else;
    break;
  }
  var G__10169 = args10164.length;
  switch (G__10169) {
    case 1:
      return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1(
        arguments[0]
      );
      break;
    case 2:
      return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10164.slice(2),
        0,
        null
      );
      return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return -x;
};
cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2 = function(
  x,
  y
) {
  return x - y;
};
cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.unchecked_subtract_int,
    x - y,
    more
  );
};
cljs.core.unchecked_subtract_int.cljs$lang$applyTo = function(seq10165) {
  var G__10166 = cljs.core.first(seq10165);
  var seq10165__$1 = cljs.core.next(seq10165);
  var G__10167 = cljs.core.first(seq10165__$1);
  var seq10165__$2 = cljs.core.next(seq10165__$1);
  return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic(
    G__10166,
    G__10167,
    seq10165__$2
  );
};
cljs.core.unchecked_subtract_int.cljs$lang$maxFixedArity = 2;
cljs.core.fix = function cljs$core$fix(q) {
  if (q >= 0) return Math.floor(q);
  else return Math.ceil(q);
};
cljs.core.int$ = function cljs$core$int(x) {
  return x | 0;
};
cljs.core.unchecked_int = function cljs$core$unchecked_int(x) {
  return cljs.core.fix(x);
};
cljs.core.long$ = function cljs$core$long(x) {
  return cljs.core.fix(x);
};
cljs.core.unchecked_long = function cljs$core$unchecked_long(x) {
  return cljs.core.fix(x);
};
cljs.core.booleans = function cljs$core$booleans(x) {
  return x;
};
cljs.core.bytes = function cljs$core$bytes(x) {
  return x;
};
cljs.core.chars = function cljs$core$chars(x) {
  return x;
};
cljs.core.shorts = function cljs$core$shorts(x) {
  return x;
};
cljs.core.ints = function cljs$core$ints(x) {
  return x;
};
cljs.core.floats = function cljs$core$floats(x) {
  return x;
};
cljs.core.doubles = function cljs$core$doubles(x) {
  return x;
};
cljs.core.longs = function cljs$core$longs(x) {
  return x;
};
cljs.core.js_mod = function cljs$core$js_mod(n, d) {
  return n % d;
};
cljs.core.mod = function cljs$core$mod(n, d) {
  return (n % d + d) % d;
};
cljs.core.quot = function cljs$core$quot(n, d) {
  var rem = n % d;
  return cljs.core.fix((n - rem) / d);
};
cljs.core.rem = function cljs$core$rem(n, d) {
  var q = cljs.core.quot(n, d);
  return n - d * q;
};
cljs.core.bit_xor = function cljs$core$bit_xor(var_args) {
  var args10174 = [];
  var len__8257__auto___10180 = arguments.length;
  var i__8258__auto___10181 = 0;
  while (true) {
    if (i__8258__auto___10181 < len__8257__auto___10180) {
      args10174.push(arguments[i__8258__auto___10181]);
      var G__10182 = i__8258__auto___10181 + 1;
      i__8258__auto___10181 = G__10182;
      continue;
    } else;
    break;
  }
  var G__10179 = args10174.length;
  switch (G__10179) {
    case 2:
      return cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10174.slice(2),
        0,
        null
      );
      return cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x ^ y;
};
cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.bit_xor,
    x ^ y,
    more
  );
};
cljs.core.bit_xor.cljs$lang$applyTo = function(seq10175) {
  var G__10176 = cljs.core.first(seq10175);
  var seq10175__$1 = cljs.core.next(seq10175);
  var G__10177 = cljs.core.first(seq10175__$1);
  var seq10175__$2 = cljs.core.next(seq10175__$1);
  return cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic(
    G__10176,
    G__10177,
    seq10175__$2
  );
};
cljs.core.bit_xor.cljs$lang$maxFixedArity = 2;
cljs.core.bit_and = function cljs$core$bit_and(var_args) {
  var args10184 = [];
  var len__8257__auto___10190 = arguments.length;
  var i__8258__auto___10191 = 0;
  while (true) {
    if (i__8258__auto___10191 < len__8257__auto___10190) {
      args10184.push(arguments[i__8258__auto___10191]);
      var G__10192 = i__8258__auto___10191 + 1;
      i__8258__auto___10191 = G__10192;
      continue;
    } else;
    break;
  }
  var G__10189 = args10184.length;
  switch (G__10189) {
    case 2:
      return cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10184.slice(2),
        0,
        null
      );
      return cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x & y;
};
cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.bit_and,
    x & y,
    more
  );
};
cljs.core.bit_and.cljs$lang$applyTo = function(seq10185) {
  var G__10186 = cljs.core.first(seq10185);
  var seq10185__$1 = cljs.core.next(seq10185);
  var G__10187 = cljs.core.first(seq10185__$1);
  var seq10185__$2 = cljs.core.next(seq10185__$1);
  return cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic(
    G__10186,
    G__10187,
    seq10185__$2
  );
};
cljs.core.bit_and.cljs$lang$maxFixedArity = 2;
cljs.core.bit_or = function cljs$core$bit_or(var_args) {
  var args10194 = [];
  var len__8257__auto___10200 = arguments.length;
  var i__8258__auto___10201 = 0;
  while (true) {
    if (i__8258__auto___10201 < len__8257__auto___10200) {
      args10194.push(arguments[i__8258__auto___10201]);
      var G__10202 = i__8258__auto___10201 + 1;
      i__8258__auto___10201 = G__10202;
      continue;
    } else;
    break;
  }
  var G__10199 = args10194.length;
  switch (G__10199) {
    case 2:
      return cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10194.slice(2),
        0,
        null
      );
      return cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x | y;
};
cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.bit_or,
    x | y,
    more
  );
};
cljs.core.bit_or.cljs$lang$applyTo = function(seq10195) {
  var G__10196 = cljs.core.first(seq10195);
  var seq10195__$1 = cljs.core.next(seq10195);
  var G__10197 = cljs.core.first(seq10195__$1);
  var seq10195__$2 = cljs.core.next(seq10195__$1);
  return cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic(
    G__10196,
    G__10197,
    seq10195__$2
  );
};
cljs.core.bit_or.cljs$lang$maxFixedArity = 2;
cljs.core.bit_and_not = function cljs$core$bit_and_not(var_args) {
  var args10204 = [];
  var len__8257__auto___10210 = arguments.length;
  var i__8258__auto___10211 = 0;
  while (true) {
    if (i__8258__auto___10211 < len__8257__auto___10210) {
      args10204.push(arguments[i__8258__auto___10211]);
      var G__10212 = i__8258__auto___10211 + 1;
      i__8258__auto___10211 = G__10212;
      continue;
    } else;
    break;
  }
  var G__10209 = args10204.length;
  switch (G__10209) {
    case 2:
      return cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10204.slice(2),
        0,
        null
      );
      return cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return x & ~y;
};
cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic = function(
  x,
  y,
  more
) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
    cljs.core.bit_and_not,
    x & ~y,
    more
  );
};
cljs.core.bit_and_not.cljs$lang$applyTo = function(seq10205) {
  var G__10206 = cljs.core.first(seq10205);
  var seq10205__$1 = cljs.core.next(seq10205);
  var G__10207 = cljs.core.first(seq10205__$1);
  var seq10205__$2 = cljs.core.next(seq10205__$1);
  return cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic(
    G__10206,
    G__10207,
    seq10205__$2
  );
};
cljs.core.bit_and_not.cljs$lang$maxFixedArity = 2;
cljs.core.bit_clear = function cljs$core$bit_clear(x, n) {
  return x & ~(1 << n);
};
cljs.core.bit_flip = function cljs$core$bit_flip(x, n) {
  return x ^ 1 << n;
};
cljs.core.bit_not = function cljs$core$bit_not(x) {
  return ~x;
};
cljs.core.bit_set = function cljs$core$bit_set(x, n) {
  return x | 1 << n;
};
cljs.core.bit_test = function cljs$core$bit_test(x, n) {
  return (x & 1 << n) != 0;
};
cljs.core.bit_shift_left = function cljs$core$bit_shift_left(x, n) {
  return x << n;
};
cljs.core.bit_shift_right = function cljs$core$bit_shift_right(x, n) {
  return x >> n;
};
cljs.core.bit_shift_right_zero_fill = function cljs$core$bit_shift_right_zero_fill(
  x,
  n
) {
  return x >>> n;
};
cljs.core.unsigned_bit_shift_right = function cljs$core$unsigned_bit_shift_right(
  x,
  n
) {
  return x >>> n;
};
cljs.core.bit_count = function cljs$core$bit_count(v) {
  var v__$1 = v - (v >> 1 & 1431655765);
  var v__$2 = (v__$1 & 858993459) + (v__$1 >> 2 & 858993459);
  return (v__$2 + (v__$2 >> 4) & 252645135) * 16843009 >> 24;
};
cljs.core._EQ__EQ_ = function cljs$core$_EQ__EQ_(var_args) {
  var args10214 = [];
  var len__8257__auto___10220 = arguments.length;
  var i__8258__auto___10221 = 0;
  while (true) {
    if (i__8258__auto___10221 < len__8257__auto___10220) {
      args10214.push(arguments[i__8258__auto___10221]);
      var G__10222 = i__8258__auto___10221 + 1;
      i__8258__auto___10221 = G__10222;
      continue;
    } else;
    break;
  }
  var G__10219 = args10214.length;
  switch (G__10219) {
    case 1:
      return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10214.slice(2),
        0,
        null
      );
      return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return true;
};
cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return cljs.core._equiv(x, y);
};
cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  while (true) {
    if (x === y)
      if (cljs.core.next(more)) {
        var G__10224 = y;
        var G__10225 = cljs.core.first(more);
        var G__10226 = cljs.core.next(more);
        x = G__10224;
        y = G__10225;
        more = G__10226;
        continue;
      } else
        return y === cljs.core.first(more);
    else
      return false;
    break;
  }
};
cljs.core._EQ__EQ_.cljs$lang$applyTo = function(seq10215) {
  var G__10216 = cljs.core.first(seq10215);
  var seq10215__$1 = cljs.core.next(seq10215);
  var G__10217 = cljs.core.first(seq10215__$1);
  var seq10215__$2 = cljs.core.next(seq10215__$1);
  return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic(
    G__10216,
    G__10217,
    seq10215__$2
  );
};
cljs.core._EQ__EQ_.cljs$lang$maxFixedArity = 2;
cljs.core.pos_QMARK_ = function cljs$core$pos_QMARK_(x) {
  return x > 0;
};
cljs.core.zero_QMARK_ = function cljs$core$zero_QMARK_(x) {
  return x === 0;
};
cljs.core.neg_QMARK_ = function cljs$core$neg_QMARK_(x) {
  return x < 0;
};
cljs.core.nthnext = function cljs$core$nthnext(coll, n) {
  var n__$1 = n;
  var xs = cljs.core.seq(coll);
  while (true) {
    if (xs && n__$1 > 0) {
      var G__10227 = n__$1 - 1;
      var G__10228 = cljs.core.next(xs);
      n__$1 = G__10227;
      xs = G__10228;
      continue;
    } else
      return xs;
    break;
  }
};
cljs.core.str = function cljs$core$str(var_args) {
  var args10229 = [];
  var len__8257__auto___10234 = arguments.length;
  var i__8258__auto___10235 = 0;
  while (true) {
    if (i__8258__auto___10235 < len__8257__auto___10234) {
      args10229.push(arguments[i__8258__auto___10235]);
      var G__10236 = i__8258__auto___10235 + 1;
      i__8258__auto___10235 = G__10236;
      continue;
    } else;
    break;
  }
  var G__10233 = args10229.length;
  switch (G__10233) {
    case 0:
      return cljs.core.str.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10229.slice(1),
        0,
        null
      );
      return cljs.core.str.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        argseq__8276__auto__
      );
  }
};
cljs.core.str.cljs$core$IFn$_invoke$arity$0 = function() {
  return '';
};
cljs.core.str.cljs$core$IFn$_invoke$arity$1 = function(x) {
  if (x == null) return '';
  else return [x].join('');
};
cljs.core.str.cljs$core$IFn$_invoke$arity$variadic = function(x, ys) {
  var sb = new goog.string.StringBuffer(
    [cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join('')
  );
  var more = ys;
  while (true) {
    if (cljs.core.truth_(more)) {
      var G__10238 = sb.append(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(more))
        ].join('')
      );
      var G__10239 = cljs.core.next(more);
      sb = G__10238;
      more = G__10239;
      continue;
    } else
      return sb.toString();
    break;
  }
};
cljs.core.str.cljs$lang$applyTo = function(seq10230) {
  var G__10231 = cljs.core.first(seq10230);
  var seq10230__$1 = cljs.core.next(seq10230);
  return cljs.core.str.cljs$core$IFn$_invoke$arity$variadic(
    G__10231,
    seq10230__$1
  );
};
cljs.core.str.cljs$lang$maxFixedArity = 1;
cljs.core.subs = function cljs$core$subs(var_args) {
  var args10240 = [];
  var len__8257__auto___10243 = arguments.length;
  var i__8258__auto___10244 = 0;
  while (true) {
    if (i__8258__auto___10244 < len__8257__auto___10243) {
      args10240.push(arguments[i__8258__auto___10244]);
      var G__10245 = i__8258__auto___10244 + 1;
      i__8258__auto___10244 = G__10245;
      continue;
    } else;
    break;
  }
  var G__10242 = args10240.length;
  switch (G__10242) {
    case 2:
      return cljs.core.subs.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.subs.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10240.length)
        ].join('')
      );
  }
};
cljs.core.subs.cljs$core$IFn$_invoke$arity$2 = function(s, start) {
  return s.substring(start);
};
cljs.core.subs.cljs$core$IFn$_invoke$arity$3 = function(s, start, end) {
  return s.substring(start, end);
};
cljs.core.subs.cljs$lang$maxFixedArity = 3;
cljs.core.equiv_sequential = function cljs$core$equiv_sequential(x, y) {
  return cljs.core.boolean$(
    cljs.core.sequential_QMARK_(y)
      ? cljs.core.counted_QMARK_(x) &&
          cljs.core.counted_QMARK_(y) &&
          !(cljs.core.count(x) === cljs.core.count(y))
          ? false
          : (function() {
              var xs = cljs.core.seq(x);
              var ys = cljs.core.seq(y);
              while (true) {
                if (xs == null)
                  return ys == null;
                else if (ys == null)
                  return false;
                else if (
                  cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
                    cljs.core.first(xs),
                    cljs.core.first(ys)
                  )
                ) {
                  var G__10247 = cljs.core.next(xs);
                  var G__10248 = cljs.core.next(ys);
                  xs = G__10247;
                  ys = G__10248;
                  continue;
                } else
                  return false;
                break;
              }
            })()
      : null
  );
};
cljs.core.hash_coll = function cljs$core$hash_coll(coll) {
  if (cljs.core.seq(coll)) {
    var res = cljs.core.hash(cljs.core.first(coll));
    var s = cljs.core.next(coll);
    while (true) {
      if (s == null)
        return res;
      else {
        var G__10249 = cljs.core.hash_combine(
          res,
          cljs.core.hash(cljs.core.first(s))
        );
        var G__10250 = cljs.core.next(s);
        res = G__10249;
        s = G__10250;
        continue;
      }
      break;
    }
  } else
    return 0;
};
cljs.core.hash_imap = function cljs$core$hash_imap(m) {
  var h = 0;
  var s = cljs.core.seq(m);
  while (true) {
    if (s) {
      var e = cljs.core.first(s);
      var G__10251 = (h +
        (cljs.core.hash(
          cljs.core.key.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.key.cljs$core$IFn$_invoke$arity$1(e)
            : cljs.core.key.call(null, e)
        ) ^
          cljs.core.hash(
            cljs.core.val.cljs$core$IFn$_invoke$arity$1
              ? cljs.core.val.cljs$core$IFn$_invoke$arity$1(e)
              : cljs.core.val.call(null, e)
          ))) %
        4503599627370496;
      var G__10252 = cljs.core.next(s);
      h = G__10251;
      s = G__10252;
      continue;
    } else
      return h;
    break;
  }
};
cljs.core.hash_iset = function cljs$core$hash_iset(s) {
  var h = 0;
  var s__$1 = cljs.core.seq(s);
  while (true) {
    if (s__$1) {
      var e = cljs.core.first(s__$1);
      var G__10253 = (h + cljs.core.hash(e)) % 4503599627370496;
      var G__10254 = cljs.core.next(s__$1);
      h = G__10253;
      s__$1 = G__10254;
      continue;
    } else
      return h;
    break;
  }
};
cljs.core.extend_object_BANG_ = function cljs$core$extend_object_BANG_(
  obj,
  fn_map
) {
  var seq__10265_10275 = cljs.core.seq(fn_map);
  var chunk__10266_10276 = null;
  var count__10267_10277 = 0;
  var i__10268_10278 = 0;
  while (true) {
    if (i__10268_10278 < count__10267_10277) {
      var vec__10269_10279 = chunk__10266_10276.cljs$core$IIndexed$_nth$arity$2(
        null,
        i__10268_10278
      );
      var key_name_10280 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
        vec__10269_10279,
        0,
        null
      );
      var f_10281 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
        vec__10269_10279,
        1,
        null
      );
      var str_name_10282 = cljs.core.name.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(key_name_10280)
        : cljs.core.name.call(null, key_name_10280);
      obj[str_name_10282] = f_10281;
      var G__10283 = seq__10265_10275;
      var G__10284 = chunk__10266_10276;
      var G__10285 = count__10267_10277;
      var G__10286 = i__10268_10278 + 1;
      seq__10265_10275 = G__10283;
      chunk__10266_10276 = G__10284;
      count__10267_10277 = G__10285;
      i__10268_10278 = G__10286;
      continue;
    } else {
      var temp__4657__auto___10287 = cljs.core.seq(seq__10265_10275);
      if (temp__4657__auto___10287) {
        var seq__10265_10288__$1 = temp__4657__auto___10287;
        if (cljs.core.chunked_seq_QMARK_(seq__10265_10288__$1)) {
          var c__7963__auto___10289 = cljs.core.chunk_first.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.chunk_first.cljs$core$IFn$_invoke$arity$1(
                seq__10265_10288__$1
              )
            : cljs.core.chunk_first.call(null, seq__10265_10288__$1);
          var G__10290 = cljs.core.chunk_rest.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.chunk_rest.cljs$core$IFn$_invoke$arity$1(
                seq__10265_10288__$1
              )
            : cljs.core.chunk_rest.call(null, seq__10265_10288__$1);
          var G__10291 = c__7963__auto___10289;
          var G__10292 = cljs.core.count(c__7963__auto___10289);
          var G__10293 = 0;
          seq__10265_10275 = G__10290;
          chunk__10266_10276 = G__10291;
          count__10267_10277 = G__10292;
          i__10268_10278 = G__10293;
          continue;
        } else {
          var vec__10272_10294 = cljs.core.first(seq__10265_10288__$1);
          var key_name_10295 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
            vec__10272_10294,
            0,
            null
          );
          var f_10296 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
            vec__10272_10294,
            1,
            null
          );
          var str_name_10297 = cljs.core.name.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(key_name_10295)
            : cljs.core.name.call(null, key_name_10295);
          obj[str_name_10297] = f_10296;
          var G__10298 = cljs.core.next(seq__10265_10288__$1);
          var G__10299 = null;
          var G__10300 = 0;
          var G__10301 = 0;
          seq__10265_10275 = G__10298;
          chunk__10266_10276 = G__10299;
          count__10267_10277 = G__10300;
          i__10268_10278 = G__10301;
          continue;
        }
      } else;
    }
    break;
  }
  return obj;
};
cljs.core.List = function(meta, first, rest, count, __hash) {
  this.meta = meta;
  this.first = first;
  this.rest = rest;
  this.count = count;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 65937646;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.List.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.List.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.List.prototype.indexOf = (function() {
  var G__10302 = null;
  var G__10302__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10302__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10302 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10302__1.call(this, x);
      case 2:
        return G__10302__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10302.cljs$core$IFn$_invoke$arity$1 = G__10302__1;
  G__10302.cljs$core$IFn$_invoke$arity$2 = G__10302__2;
  return G__10302;
})();
cljs.core.List.prototype.lastIndexOf = (function() {
  var G__10303 = null;
  var G__10303__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      self__.count
    );
  };
  var G__10303__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10303 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10303__1.call(this, x);
      case 2:
        return G__10303__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10303.cljs$core$IFn$_invoke$arity$1 = G__10303__1;
  G__10303.cljs$core$IFn$_invoke$arity$2 = G__10303__2;
  return G__10303;
})();
cljs.core.List.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.List.prototype.cljs$core$ICloneable$_clone$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.List(
    self__.meta,
    self__.first,
    self__.rest,
    self__.count,
    self__.__hash
  );
};
cljs.core.List.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.count === 1) return null;
  else return self__.rest;
};
cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.count;
};
cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.first;
};
cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$ISeq$_rest$arity$1(null);
};
cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.List.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core._with_meta(cljs.core.List.EMPTY, self__.meta);
};
cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, coll__$1);
};
cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, start, coll__$1);
};
cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.first;
};
cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.count === 1) return cljs.core.List.EMPTY;
  else return self__.rest;
};
cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.List(
    meta__$1,
    self__.first,
    self__.rest,
    self__.count,
    self__.__hash
  );
};
cljs.core.List.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.List(self__.meta, o, coll__$1, self__.count + 1, null);
};
cljs.core.List.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    5,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'first', 'first', 996428481, null),
      new cljs.core.Symbol(null, 'rest', 'rest', 398835108, null),
      new cljs.core.Symbol(null, 'count', 'count', -514511684, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.List.cljs$lang$type = true;
cljs.core.List.cljs$lang$ctorStr = 'cljs.core/List';
cljs.core.List.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/List');
};
cljs.core.__GT_List = function cljs$core$__GT_List(
  meta,
  first,
  rest,
  count,
  __hash
) {
  return new cljs.core.List(meta, first, rest, count, __hash);
};
cljs.core.list_QMARK_ = function cljs$core$list_QMARK_(x) {
  if (!(x == null))
    if (
      x.cljs$lang$protocol_mask$partition0$ & 33554432 ||
      cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IList$
    )
      return true;
    else if (!x.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IList, x);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IList, x);
};
cljs.core.List.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.EmptyList = function(meta) {
  this.meta = meta;
  this.cljs$lang$protocol_mask$partition0$ = 65937614;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.EmptyList.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.EmptyList.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.EmptyList.prototype.indexOf = (function() {
  var G__10306 = null;
  var G__10306__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10306__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10306 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10306__1.call(this, x);
      case 2:
        return G__10306__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10306.cljs$core$IFn$_invoke$arity$1 = G__10306__1;
  G__10306.cljs$core$IFn$_invoke$arity$2 = G__10306__2;
  return G__10306;
})();
cljs.core.EmptyList.prototype.lastIndexOf = (function() {
  var G__10307 = null;
  var G__10307__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__10307__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10307 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10307__1.call(this, x);
      case 2:
        return G__10307__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10307.cljs$core$IFn$_invoke$arity$1 = G__10307__1;
  G__10307.cljs$core$IFn$_invoke$arity$2 = G__10307__2;
  return G__10307;
})();
cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.EmptyList.prototype.cljs$core$ICloneable$_clone$arity$1 = function(
  _
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.EmptyList(self__.meta);
};
cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return null;
};
cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return 0;
};
cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return null;
};
cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  throw new Error("Can't pop empty list");
};
cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.empty_ordered_hash;
};
cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  if (cljs.core.list_QMARK_(other) || cljs.core.sequential_QMARK_(other))
    return cljs.core.seq(other) == null;
  else
    return false;
};
cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, coll__$1);
};
cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, start, coll__$1);
};
cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return null;
};
cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.List.EMPTY;
};
cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return null;
};
cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.EmptyList(meta__$1);
};
cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.List(self__.meta, o, null, 1, null);
};
cljs.core.EmptyList.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    1,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null)],
    null
  );
};
cljs.core.EmptyList.cljs$lang$type = true;
cljs.core.EmptyList.cljs$lang$ctorStr = 'cljs.core/EmptyList';
cljs.core.EmptyList.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/EmptyList');
};
cljs.core.__GT_EmptyList = function cljs$core$__GT_EmptyList(meta) {
  return new cljs.core.EmptyList(meta);
};
cljs.core.List.EMPTY = new cljs.core.EmptyList(null);
cljs.core.EmptyList.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.reversible_QMARK_ = function cljs$core$reversible_QMARK_(coll) {
  if (!(coll == null))
    if (
      coll.cljs$lang$protocol_mask$partition0$ & 134217728 ||
      cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReversible$
    )
      return true;
    else if (!coll.cljs$lang$protocol_mask$partition0$)
      return cljs.core.native_satisfies_QMARK_(cljs.core.IReversible, coll);
    else
      return false;
  else
    return cljs.core.native_satisfies_QMARK_(cljs.core.IReversible, coll);
};
cljs.core.rseq = function cljs$core$rseq(rev) {
  return cljs.core._rseq(rev);
};
cljs.core.reverse = function cljs$core$reverse(coll) {
  if (cljs.core.reversible_QMARK_(coll)) return cljs.core.rseq(coll);
  else return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
      cljs.core.conj,
      cljs.core.List.EMPTY,
      coll
    );
};
cljs.core.list = function cljs$core$list(var_args) {
  var args__8264__auto__ = [];
  var len__8257__auto___10311 = arguments.length;
  var i__8258__auto___10312 = 0;
  while (true) {
    if (i__8258__auto___10312 < len__8257__auto___10311) {
      args__8264__auto__.push(arguments[i__8258__auto___10312]);
      var G__10313 = i__8258__auto___10312 + 1;
      i__8258__auto___10312 = G__10313;
      continue;
    } else;
    break;
  }
  var argseq__8265__auto__ = 0 < args__8264__auto__.length
    ? new cljs.core.IndexedSeq(args__8264__auto__.slice(0), 0, null)
    : null;
  return cljs.core.list.cljs$core$IFn$_invoke$arity$variadic(
    argseq__8265__auto__
  );
};
cljs.core.list.cljs$core$IFn$_invoke$arity$variadic = function(xs) {
  var arr = xs instanceof cljs.core.IndexedSeq && xs.i === 0
    ? xs.arr
    : (function() {
        var arr = [];
        var xs__$1 = xs;
        while (true) {
          if (!(xs__$1 == null)) {
            arr.push(xs__$1.cljs$core$ISeq$_first$arity$1(null));
            var G__10314 = xs__$1.cljs$core$INext$_next$arity$1(null);
            xs__$1 = G__10314;
            continue;
          } else
            return arr;
          break;
        }
      })();
  var i = arr.length;
  var r = cljs.core.List.EMPTY;
  while (true) {
    if (i > 0) {
      var G__10315 = i - 1;
      var G__10316 = r.cljs$core$ICollection$_conj$arity$2(null, arr[i - 1]);
      i = G__10315;
      r = G__10316;
      continue;
    } else
      return r;
    break;
  }
};
cljs.core.list.cljs$lang$maxFixedArity = 0;
cljs.core.list.cljs$lang$applyTo = function(seq10310) {
  return cljs.core.list.cljs$core$IFn$_invoke$arity$variadic(
    cljs.core.seq(seq10310)
  );
};
cljs.core.Cons = function(meta, first, rest, __hash) {
  this.meta = meta;
  this.first = first;
  this.rest = rest;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 65929452;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.Cons.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.Cons.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.Cons.prototype.indexOf = (function() {
  var G__10317 = null;
  var G__10317__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10317__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10317 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10317__1.call(this, x);
      case 2:
        return G__10317__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10317.cljs$core$IFn$_invoke$arity$1 = G__10317__1;
  G__10317.cljs$core$IFn$_invoke$arity$2 = G__10317__2;
  return G__10317;
})();
cljs.core.Cons.prototype.lastIndexOf = (function() {
  var G__10318 = null;
  var G__10318__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__10318__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10318 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10318__1.call(this, x);
      case 2:
        return G__10318__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10318.cljs$core$IFn$_invoke$arity$1 = G__10318__1;
  G__10318.cljs$core$IFn$_invoke$arity$2 = G__10318__2;
  return G__10318;
})();
cljs.core.Cons.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.Cons.prototype.cljs$core$ICloneable$_clone$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.Cons(
    self__.meta,
    self__.first,
    self__.rest,
    self__.__hash
  );
};
cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.rest == null) return null;
  else return cljs.core.seq(self__.rest);
};
cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.Cons.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.List.EMPTY, self__.meta);
};
cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, coll__$1);
};
cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, start, coll__$1);
};
cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.first;
};
cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.rest == null) return cljs.core.List.EMPTY;
  else return self__.rest;
};
cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.Cons(meta__$1, self__.first, self__.rest, self__.__hash);
};
cljs.core.Cons.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.Cons(null, o, coll__$1, null);
};
cljs.core.Cons.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'first', 'first', 996428481, null),
      new cljs.core.Symbol(null, 'rest', 'rest', 398835108, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.Cons.cljs$lang$type = true;
cljs.core.Cons.cljs$lang$ctorStr = 'cljs.core/Cons';
cljs.core.Cons.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Cons');
};
cljs.core.__GT_Cons = function cljs$core$__GT_Cons(meta, first, rest, __hash) {
  return new cljs.core.Cons(meta, first, rest, __hash);
};
cljs.core.Cons.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.cons = function cljs$core$cons(x, coll) {
  if (
    (function() {
      var or__7144__auto__ = coll == null;
      if (or__7144__auto__) return or__7144__auto__;
      else if (!(coll == null))
        if (
          coll.cljs$lang$protocol_mask$partition0$ & 64 ||
          cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$
        )
          return true;
        else
          return false;
      else
        return false;
    })()
  )
    return new cljs.core.Cons(null, x, coll, null);
  else
    return new cljs.core.Cons(null, x, cljs.core.seq(coll), null);
};
cljs.core.hash_keyword = function cljs$core$hash_keyword(k) {
  return cljs.core.hash_symbol(k) + 2654435769 | 0;
};
cljs.core.compare_keywords = function cljs$core$compare_keywords(a, b) {
  if (a.fqn === b.fqn)
    return 0;
  else if (
    cljs.core.truth_(
      (function() {
        var and__7132__auto__ = cljs.core.not(a.ns);
        if (and__7132__auto__) return b.ns;
        else return and__7132__auto__;
      })()
    )
  )
    return -1;
  else if (cljs.core.truth_(a.ns))
    if (cljs.core.not(b.ns))
      return 1;
    else {
      var nsc = (function() {
        var G__10329 = a.ns;
        var G__10330 = b.ns;
        return goog.array.defaultCompare(G__10329, G__10330);
      })();
      if (0 === nsc) {
        var G__10331 = a.name;
        var G__10332 = b.name;
        return goog.array.defaultCompare(G__10331, G__10332);
      } else
        return nsc;
    }
  else {
    var G__10333 = a.name;
    var G__10334 = b.name;
    return goog.array.defaultCompare(G__10333, G__10334);
  }
};
cljs.core.Keyword = function(ns, name, fqn, _hash) {
  this.ns = ns;
  this.name = name;
  this.fqn = fqn;
  this._hash = _hash;
  this.cljs$lang$protocol_mask$partition0$ = 2153775105;
  this.cljs$lang$protocol_mask$partition1$ = 4096;
};
cljs.core.Keyword.prototype.toString = function() {
  var self__ = this;
  var _ = this;
  return [
    cljs.core.str.cljs$core$IFn$_invoke$arity$1(':'),
    cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)
  ].join('');
};
cljs.core.Keyword.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.Keyword.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  _,
  other
) {
  var self__ = this;
  var ___$1 = this;
  if (other instanceof cljs.core.Keyword) return self__.fqn === other.fqn;
  else return false;
};
cljs.core.Keyword.prototype.call = (function() {
  var G__10336 = null;
  var G__10336__2 = function(self__, coll) {
    var self__ = this;
    var self____$1 = this;
    var kw = self____$1;
    return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll, kw);
  };
  var G__10336__3 = function(self__, coll, not_found) {
    var self__ = this;
    var self____$1 = this;
    var kw = self____$1;
    return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll, kw, not_found);
  };
  G__10336 = function(self__, coll, not_found) {
    switch (arguments.length) {
      case 2:
        return G__10336__2.call(this, self__, coll);
      case 3:
        return G__10336__3.call(this, self__, coll, not_found);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10336.cljs$core$IFn$_invoke$arity$2 = G__10336__2;
  G__10336.cljs$core$IFn$_invoke$arity$3 = G__10336__3;
  return G__10336;
})();
cljs.core.Keyword.prototype.apply = function(self__, args10335) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args10335))
  );
};
cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  var self__ = this;
  var kw = this;
  return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll, kw);
};
cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$2 = function(
  coll,
  not_found
) {
  var self__ = this;
  var kw = this;
  return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll, kw, not_found);
};
cljs.core.Keyword.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
  var self__ = this;
  var this$__$1 = this;
  var h__7584__auto__ = self__._hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_keyword(this$__$1);
    self__._hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.Keyword.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.name;
};
cljs.core.Keyword.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.ns;
};
cljs.core.Keyword.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(
  o,
  writer,
  _
) {
  var self__ = this;
  var o__$1 = this;
  return cljs.core._write(
    writer,
    [
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(':'),
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)
    ].join('')
  );
};
cljs.core.Keyword.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'ns', 'ns', 2082130287, null),
      new cljs.core.Symbol(null, 'name', 'name', -810760592, null),
      new cljs.core.Symbol(null, 'fqn', 'fqn', -1749334463, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '_hash', '_hash', -2130838312, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.Keyword.cljs$lang$type = true;
cljs.core.Keyword.cljs$lang$ctorStr = 'cljs.core/Keyword';
cljs.core.Keyword.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Keyword');
};
cljs.core.__GT_Keyword = function cljs$core$__GT_Keyword(ns, name, fqn, _hash) {
  return new cljs.core.Keyword(ns, name, fqn, _hash);
};
cljs.core.keyword_QMARK_ = function cljs$core$keyword_QMARK_(x) {
  return x instanceof cljs.core.Keyword;
};
cljs.core.keyword_identical_QMARK_ = function cljs$core$keyword_identical_QMARK_(
  x,
  y
) {
  if (x === y) return true;
  else if (x instanceof cljs.core.Keyword && y instanceof cljs.core.Keyword)
    return x.fqn === y.fqn;
  else
    return false;
};
cljs.core.symbol_identical_QMARK_ = function cljs$core$symbol_identical_QMARK_(
  x,
  y
) {
  if (x === y) return true;
  else if (x instanceof cljs.core.Symbol && y instanceof cljs.core.Symbol)
    return x.str === y.str;
  else
    return false;
};
cljs.core.namespace = function cljs$core$namespace(x) {
  if (
    !(x == null)
      ? x.cljs$lang$protocol_mask$partition1$ & 4096 ||
          cljs.core.PROTOCOL_SENTINEL === x.cljs$core$INamed$
          ? true
          : false
      : false
  )
    return x.cljs$core$INamed$_namespace$arity$1(null);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          "Doesn't support namespace: "
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)
      ].join('')
    );
};
cljs.core.ident_QMARK_ = function cljs$core$ident_QMARK_(x) {
  return x instanceof cljs.core.Keyword || x instanceof cljs.core.Symbol;
};
cljs.core.simple_ident_QMARK_ = function cljs$core$simple_ident_QMARK_(x) {
  return cljs.core.ident_QMARK_(x) && cljs.core.namespace(x) == null;
};
cljs.core.qualified_ident_QMARK_ = function cljs$core$qualified_ident_QMARK_(
  x
) {
  var and__7132__auto__ = cljs.core.ident_QMARK_(x);
  if (and__7132__auto__) {
    var and__7132__auto____$1 = cljs.core.namespace(x);
    if (cljs.core.truth_(and__7132__auto____$1)) return true;
    else return and__7132__auto____$1;
  } else
    return and__7132__auto__;
};
cljs.core.simple_symbol_QMARK_ = function cljs$core$simple_symbol_QMARK_(x) {
  return x instanceof cljs.core.Symbol && cljs.core.namespace(x) == null;
};
cljs.core.qualified_symbol_QMARK_ = function cljs$core$qualified_symbol_QMARK_(
  x
) {
  var and__7132__auto__ = x instanceof cljs.core.Symbol;
  if (and__7132__auto__) {
    var and__7132__auto____$1 = cljs.core.namespace(x);
    if (cljs.core.truth_(and__7132__auto____$1)) return true;
    else return and__7132__auto____$1;
  } else
    return and__7132__auto__;
};
cljs.core.simple_keyword_QMARK_ = function cljs$core$simple_keyword_QMARK_(x) {
  return x instanceof cljs.core.Keyword && cljs.core.namespace(x) == null;
};
cljs.core.qualified_keyword_QMARK_ = function cljs$core$qualified_keyword_QMARK_(
  x
) {
  var and__7132__auto__ = x instanceof cljs.core.Keyword;
  if (and__7132__auto__) {
    var and__7132__auto____$1 = cljs.core.namespace(x);
    if (cljs.core.truth_(and__7132__auto____$1)) return true;
    else return and__7132__auto____$1;
  } else
    return and__7132__auto__;
};
cljs.core.keyword = function cljs$core$keyword(var_args) {
  var args10339 = [];
  var len__8257__auto___10342 = arguments.length;
  var i__8258__auto___10343 = 0;
  while (true) {
    if (i__8258__auto___10343 < len__8257__auto___10342) {
      args10339.push(arguments[i__8258__auto___10343]);
      var G__10344 = i__8258__auto___10343 + 1;
      i__8258__auto___10343 = G__10344;
      continue;
    } else;
    break;
  }
  var G__10341 = args10339.length;
  switch (G__10341) {
    case 1:
      return cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10339.length)
        ].join('')
      );
  }
};
cljs.core.keyword.cljs$core$IFn$_invoke$arity$1 = function(name) {
  if (name instanceof cljs.core.Keyword)
    return name;
  else if (name instanceof cljs.core.Symbol)
    return new cljs.core.Keyword(
      cljs.core.namespace(name),
      cljs.core.name.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(name)
        : cljs.core.name.call(null, name),
      name.str,
      null
    );
  else if (typeof name === 'string') {
    var parts = name.split('/');
    if (parts.length === 2)
      return new cljs.core.Keyword(parts[0], parts[1], name, null);
    else
      return new cljs.core.Keyword(null, parts[0], name, null);
  } else
    return null;
};
cljs.core.keyword.cljs$core$IFn$_invoke$arity$2 = function(ns, name) {
  var ns__$1 = ns instanceof cljs.core.Keyword
    ? cljs.core.name.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(ns)
        : cljs.core.name.call(null, ns)
    : ns instanceof cljs.core.Symbol
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(ns)
            : cljs.core.name.call(null, ns)
        : ns;
  var name__$1 = name instanceof cljs.core.Keyword
    ? cljs.core.name.cljs$core$IFn$_invoke$arity$1
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(name)
        : cljs.core.name.call(null, name)
    : name instanceof cljs.core.Symbol
        ? cljs.core.name.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.name.cljs$core$IFn$_invoke$arity$1(name)
            : cljs.core.name.call(null, name)
        : name;
  return new cljs.core.Keyword(
    ns__$1,
    name__$1,
    [
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(
        cljs.core.truth_(ns__$1)
          ? [
              cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns__$1),
              cljs.core.str.cljs$core$IFn$_invoke$arity$1('/')
            ].join('')
          : null
      ),
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(name__$1)
    ].join(''),
    null
  );
};
cljs.core.keyword.cljs$lang$maxFixedArity = 2;
cljs.core.LazySeq = function(meta, fn, s, __hash) {
  this.meta = meta;
  this.fn = fn;
  this.s = s;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 32374988;
  this.cljs$lang$protocol_mask$partition1$ = 1;
};
cljs.core.LazySeq.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.LazySeq.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.LazySeq.prototype.sval = function() {
  var self__ = this;
  var coll = this;
  if (self__.fn == null)
    return self__.s;
  else {
    self__.s = self__.fn.cljs$core$IFn$_invoke$arity$0
      ? self__.fn.cljs$core$IFn$_invoke$arity$0()
      : self__.fn.call(null);
    self__.fn = null;
    return self__.s;
  }
};
cljs.core.LazySeq.prototype.indexOf = (function() {
  var G__10346 = null;
  var G__10346__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10346__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10346 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10346__1.call(this, x);
      case 2:
        return G__10346__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10346.cljs$core$IFn$_invoke$arity$1 = G__10346__1;
  G__10346.cljs$core$IFn$_invoke$arity$2 = G__10346__2;
  return G__10346;
})();
cljs.core.LazySeq.prototype.lastIndexOf = (function() {
  var G__10347 = null;
  var G__10347__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__10347__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10347 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10347__1.call(this, x);
      case 2:
        return G__10347__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10347.cljs$core$IFn$_invoke$arity$1 = G__10347__1;
  G__10347.cljs$core$IFn$_invoke$arity$2 = G__10347__2;
  return G__10347;
})();
cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  coll__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (self__.s == null) return null;
  else return cljs.core.next(self__.s);
};
cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.List.EMPTY, self__.meta);
};
cljs.core.LazySeq.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.not(self__.fn);
};
cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f, coll__$1);
};
cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f, start, coll__$1);
};
cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  coll__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (self__.s == null) return null;
  else return cljs.core.first(self__.s);
};
cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  coll__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (!(self__.s == null)) return cljs.core.rest(self__.s);
  else return cljs.core.List.EMPTY;
};
cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  coll__$1.sval();
  if (self__.s == null)
    return null;
  else {
    var ls = self__.s;
    while (true) {
      if (ls instanceof cljs.core.LazySeq) {
        var G__10348 = ls.sval();
        ls = G__10348;
        continue;
      } else {
        self__.s = ls;
        return cljs.core.seq(self__.s);
      }
      break;
    }
  }
};
cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.LazySeq(meta__$1, self__.fn, self__.s, self__.__hash);
};
cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.cons(o, coll__$1);
};
cljs.core.LazySeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'fn', 'fn', 465265323, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 's', 's', -948495851, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.LazySeq.cljs$lang$type = true;
cljs.core.LazySeq.cljs$lang$ctorStr = 'cljs.core/LazySeq';
cljs.core.LazySeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/LazySeq');
};
cljs.core.__GT_LazySeq = function cljs$core$__GT_LazySeq(meta, fn, s, __hash) {
  return new cljs.core.LazySeq(meta, fn, s, __hash);
};
cljs.core.LazySeq.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.ChunkBuffer = function(buf, end) {
  this.buf = buf;
  this.end = end;
  this.cljs$lang$protocol_mask$partition0$ = 2;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.ChunkBuffer.prototype.add = function(o) {
  var self__ = this;
  var _ = this;
  self__.buf[self__.end] = o;
  return (self__.end = self__.end + 1);
};
cljs.core.ChunkBuffer.prototype.chunk = function(o) {
  var self__ = this;
  var _ = this;
  var ret = new cljs.core.ArrayChunk(self__.buf, 0, self__.end);
  self__.buf = null;
  return ret;
};
cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 = function(
  _
) {
  var self__ = this;
  var ___$1 = this;
  return self__.end;
};
cljs.core.ChunkBuffer.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'buf', 'buf', 1426618187, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'end', 'end', 1372345569, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ChunkBuffer.cljs$lang$type = true;
cljs.core.ChunkBuffer.cljs$lang$ctorStr = 'cljs.core/ChunkBuffer';
cljs.core.ChunkBuffer.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ChunkBuffer');
};
cljs.core.__GT_ChunkBuffer = function cljs$core$__GT_ChunkBuffer(buf, end) {
  return new cljs.core.ChunkBuffer(buf, end);
};
cljs.core.chunk_buffer = function cljs$core$chunk_buffer(capacity) {
  return new cljs.core.ChunkBuffer(new Array(capacity), 0);
};
cljs.core.ArrayChunk = function(arr, off, end) {
  this.arr = arr;
  this.off = off;
  this.end = end;
  this.cljs$lang$protocol_mask$partition0$ = 524306;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.end - self__.off;
};
cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$2 = function(
  coll,
  i
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.arr[self__.off + i];
};
cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$3 = function(
  coll,
  i,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (i >= 0 && i < self__.end - self__.off) return self__.arr[self__.off + i];
  else return not_found;
};
cljs.core.ArrayChunk.prototype.cljs$core$IChunk$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.ArrayChunk.prototype.cljs$core$IChunk$_drop_first$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.off === self__.end) throw new Error('-drop-first of empty chunk');
  else return new cljs.core.ArrayChunk(self__.arr, self__.off + 1, self__.end);
};
cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(
    self__.arr,
    f,
    self__.arr[self__.off],
    self__.off + 1
  );
};
cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(
    self__.arr,
    f,
    start,
    self__.off
  );
};
cljs.core.ArrayChunk.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null),
      new cljs.core.Symbol(null, 'off', 'off', -2047994980, null),
      new cljs.core.Symbol(null, 'end', 'end', 1372345569, null)
    ],
    null
  );
};
cljs.core.ArrayChunk.cljs$lang$type = true;
cljs.core.ArrayChunk.cljs$lang$ctorStr = 'cljs.core/ArrayChunk';
cljs.core.ArrayChunk.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ArrayChunk');
};
cljs.core.__GT_ArrayChunk = function cljs$core$__GT_ArrayChunk(arr, off, end) {
  return new cljs.core.ArrayChunk(arr, off, end);
};
cljs.core.array_chunk = function cljs$core$array_chunk(var_args) {
  var args10349 = [];
  var len__8257__auto___10352 = arguments.length;
  var i__8258__auto___10353 = 0;
  while (true) {
    if (i__8258__auto___10353 < len__8257__auto___10352) {
      args10349.push(arguments[i__8258__auto___10353]);
      var G__10354 = i__8258__auto___10353 + 1;
      i__8258__auto___10353 = G__10354;
      continue;
    } else;
    break;
  }
  var G__10351 = args10349.length;
  switch (G__10351) {
    case 1:
      return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10349.length)
        ].join('')
      );
  }
};
cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1 = function(arr) {
  return new cljs.core.ArrayChunk(arr, 0, arr.length);
};
cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2 = function(arr, off) {
  return new cljs.core.ArrayChunk(arr, off, arr.length);
};
cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3 = function(arr, off, end) {
  return new cljs.core.ArrayChunk(arr, off, end);
};
cljs.core.array_chunk.cljs$lang$maxFixedArity = 3;
cljs.core.ChunkedCons = function(chunk, more, meta, __hash) {
  this.chunk = chunk;
  this.more = more;
  this.meta = meta;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 31850732;
  this.cljs$lang$protocol_mask$partition1$ = 1536;
};
cljs.core.ChunkedCons.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.ChunkedCons.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.ChunkedCons.prototype.indexOf = (function() {
  var G__10356 = null;
  var G__10356__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10356__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10356 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10356__1.call(this, x);
      case 2:
        return G__10356__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10356.cljs$core$IFn$_invoke$arity$1 = G__10356__1;
  G__10356.cljs$core$IFn$_invoke$arity$2 = G__10356__2;
  return G__10356;
})();
cljs.core.ChunkedCons.prototype.lastIndexOf = (function() {
  var G__10357 = null;
  var G__10357__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__10357__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10357 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10357__1.call(this, x);
      case 2:
        return G__10357__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10357.cljs$core$IFn$_invoke$arity$1 = G__10357__1;
  G__10357.cljs$core$IFn$_invoke$arity$2 = G__10357__2;
  return G__10357;
})();
cljs.core.ChunkedCons.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.ChunkedCons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (cljs.core._count(self__.chunk) > 1)
    return new cljs.core.ChunkedCons(
      cljs.core._drop_first(self__.chunk),
      self__.more,
      self__.meta,
      null
    );
  else {
    var more__$1 = cljs.core._seq(self__.more);
    if (more__$1 == null) return null;
    else return more__$1;
  }
};
cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.ChunkedCons.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.List.EMPTY, self__.meta);
};
cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.chunk, 0);
};
cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (cljs.core._count(self__.chunk) > 1)
    return new cljs.core.ChunkedCons(
      cljs.core._drop_first(self__.chunk),
      self__.more,
      self__.meta,
      null
    );
  else if (self__.more == null) return cljs.core.List.EMPTY;
  else return self__.more;
};
cljs.core.ChunkedCons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.chunk;
};
cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.more == null) return cljs.core.List.EMPTY;
  else return self__.more;
};
cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  m
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.ChunkedCons(self__.chunk, self__.more, m, self__.__hash);
};
cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  this$,
  o
) {
  var self__ = this;
  var this$__$1 = this;
  return cljs.core.cons(o, this$__$1);
};
cljs.core.ChunkedCons.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.more == null) return null;
  else return self__.more;
};
cljs.core.ChunkedCons.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'chunk', 'chunk', 449371907, null),
      new cljs.core.Symbol(null, 'more', 'more', -418290273, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ChunkedCons.cljs$lang$type = true;
cljs.core.ChunkedCons.cljs$lang$ctorStr = 'cljs.core/ChunkedCons';
cljs.core.ChunkedCons.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ChunkedCons');
};
cljs.core.__GT_ChunkedCons = function cljs$core$__GT_ChunkedCons(
  chunk,
  more,
  meta,
  __hash
) {
  return new cljs.core.ChunkedCons(chunk, more, meta, __hash);
};
cljs.core.ChunkedCons.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.chunk_cons = function cljs$core$chunk_cons(chunk, rest) {
  if (cljs.core._count(chunk) === 0) return rest;
  else return new cljs.core.ChunkedCons(chunk, rest, null, null);
};
cljs.core.chunk_append = function cljs$core$chunk_append(b, x) {
  return b.add(x);
};
cljs.core.chunk = function cljs$core$chunk(b) {
  return b.chunk();
};
cljs.core.chunk_first = function cljs$core$chunk_first(s) {
  return cljs.core._chunked_first(s);
};
cljs.core.chunk_rest = function cljs$core$chunk_rest(s) {
  return cljs.core._chunked_rest(s);
};
cljs.core.chunk_next = function cljs$core$chunk_next(s) {
  if (
    !(s == null)
      ? s.cljs$lang$protocol_mask$partition1$ & 1024 ||
          cljs.core.PROTOCOL_SENTINEL === s.cljs$core$IChunkedNext$
          ? true
          : false
      : false
  )
    return cljs.core._chunked_next(s);
  else
    return cljs.core.seq(cljs.core._chunked_rest(s));
};
cljs.core.to_array = function cljs$core$to_array(s) {
  var ary = [];
  var s__$1 = s;
  while (true) {
    if (cljs.core.seq(s__$1)) {
      ary.push(cljs.core.first(s__$1));
      var G__10360 = cljs.core.next(s__$1);
      s__$1 = G__10360;
      continue;
    } else
      return ary;
    break;
  }
};
cljs.core.to_array_2d = function cljs$core$to_array_2d(coll) {
  var ret = new Array(cljs.core.count(coll));
  var i_10361 = 0;
  var xs_10362 = cljs.core.seq(coll);
  while (true) {
    if (xs_10362) {
      ret[i_10361] = cljs.core.to_array(cljs.core.first(xs_10362));
      var G__10363 = i_10361 + 1;
      var G__10364 = cljs.core.next(xs_10362);
      i_10361 = G__10363;
      xs_10362 = G__10364;
      continue;
    } else;
    break;
  }
  return ret;
};
cljs.core.int_array = function cljs$core$int_array(var_args) {
  var args10365 = [];
  var len__8257__auto___10368 = arguments.length;
  var i__8258__auto___10369 = 0;
  while (true) {
    if (i__8258__auto___10369 < len__8257__auto___10368) {
      args10365.push(arguments[i__8258__auto___10369]);
      var G__10370 = i__8258__auto___10369 + 1;
      i__8258__auto___10369 = G__10370;
      continue;
    } else;
    break;
  }
  var G__10367 = args10365.length;
  switch (G__10367) {
    case 1:
      return cljs.core.int_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.int_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10365.length)
        ].join('')
      );
  }
};
cljs.core.int_array.cljs$core$IFn$_invoke$arity$1 = function(size_or_seq) {
  if (typeof size_or_seq === 'number')
    return cljs.core.int_array.cljs$core$IFn$_invoke$arity$2(size_or_seq, null);
  else
    return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);
};
cljs.core.int_array.cljs$core$IFn$_invoke$arity$2 = function(
  size,
  init_val_or_seq
) {
  var a = new Array(size);
  if (cljs.core.seq_QMARK_(init_val_or_seq)) {
    var s = cljs.core.seq(init_val_or_seq);
    var i = 0;
    var s__$1 = s;
    while (true) {
      if (s__$1 && i < size) {
        a[i] = cljs.core.first(s__$1);
        var G__10372 = i + 1;
        var G__10373 = cljs.core.next(s__$1);
        i = G__10372;
        s__$1 = G__10373;
        continue;
      } else
        return a;
      break;
    }
  } else {
    var n__8067__auto___10374 = size;
    var i_10375 = 0;
    while (true) {
      if (i_10375 < n__8067__auto___10374) {
        a[i_10375] = init_val_or_seq;
        var G__10376 = i_10375 + 1;
        i_10375 = G__10376;
        continue;
      } else;
      break;
    }
    return a;
  }
};
cljs.core.int_array.cljs$lang$maxFixedArity = 2;
cljs.core.long_array = function cljs$core$long_array(var_args) {
  var args10377 = [];
  var len__8257__auto___10380 = arguments.length;
  var i__8258__auto___10381 = 0;
  while (true) {
    if (i__8258__auto___10381 < len__8257__auto___10380) {
      args10377.push(arguments[i__8258__auto___10381]);
      var G__10382 = i__8258__auto___10381 + 1;
      i__8258__auto___10381 = G__10382;
      continue;
    } else;
    break;
  }
  var G__10379 = args10377.length;
  switch (G__10379) {
    case 1:
      return cljs.core.long_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.long_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10377.length)
        ].join('')
      );
  }
};
cljs.core.long_array.cljs$core$IFn$_invoke$arity$1 = function(size_or_seq) {
  if (typeof size_or_seq === 'number')
    return cljs.core.long_array.cljs$core$IFn$_invoke$arity$2(
      size_or_seq,
      null
    );
  else
    return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);
};
cljs.core.long_array.cljs$core$IFn$_invoke$arity$2 = function(
  size,
  init_val_or_seq
) {
  var a = new Array(size);
  if (cljs.core.seq_QMARK_(init_val_or_seq)) {
    var s = cljs.core.seq(init_val_or_seq);
    var i = 0;
    var s__$1 = s;
    while (true) {
      if (s__$1 && i < size) {
        a[i] = cljs.core.first(s__$1);
        var G__10384 = i + 1;
        var G__10385 = cljs.core.next(s__$1);
        i = G__10384;
        s__$1 = G__10385;
        continue;
      } else
        return a;
      break;
    }
  } else {
    var n__8067__auto___10386 = size;
    var i_10387 = 0;
    while (true) {
      if (i_10387 < n__8067__auto___10386) {
        a[i_10387] = init_val_or_seq;
        var G__10388 = i_10387 + 1;
        i_10387 = G__10388;
        continue;
      } else;
      break;
    }
    return a;
  }
};
cljs.core.long_array.cljs$lang$maxFixedArity = 2;
cljs.core.double_array = function cljs$core$double_array(var_args) {
  var args10389 = [];
  var len__8257__auto___10392 = arguments.length;
  var i__8258__auto___10393 = 0;
  while (true) {
    if (i__8258__auto___10393 < len__8257__auto___10392) {
      args10389.push(arguments[i__8258__auto___10393]);
      var G__10394 = i__8258__auto___10393 + 1;
      i__8258__auto___10393 = G__10394;
      continue;
    } else;
    break;
  }
  var G__10391 = args10389.length;
  switch (G__10391) {
    case 1:
      return cljs.core.double_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.double_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10389.length)
        ].join('')
      );
  }
};
cljs.core.double_array.cljs$core$IFn$_invoke$arity$1 = function(size_or_seq) {
  if (typeof size_or_seq === 'number')
    return cljs.core.double_array.cljs$core$IFn$_invoke$arity$2(
      size_or_seq,
      null
    );
  else
    return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);
};
cljs.core.double_array.cljs$core$IFn$_invoke$arity$2 = function(
  size,
  init_val_or_seq
) {
  var a = new Array(size);
  if (cljs.core.seq_QMARK_(init_val_or_seq)) {
    var s = cljs.core.seq(init_val_or_seq);
    var i = 0;
    var s__$1 = s;
    while (true) {
      if (s__$1 && i < size) {
        a[i] = cljs.core.first(s__$1);
        var G__10396 = i + 1;
        var G__10397 = cljs.core.next(s__$1);
        i = G__10396;
        s__$1 = G__10397;
        continue;
      } else
        return a;
      break;
    }
  } else {
    var n__8067__auto___10398 = size;
    var i_10399 = 0;
    while (true) {
      if (i_10399 < n__8067__auto___10398) {
        a[i_10399] = init_val_or_seq;
        var G__10400 = i_10399 + 1;
        i_10399 = G__10400;
        continue;
      } else;
      break;
    }
    return a;
  }
};
cljs.core.double_array.cljs$lang$maxFixedArity = 2;
cljs.core.object_array = function cljs$core$object_array(var_args) {
  var args10401 = [];
  var len__8257__auto___10404 = arguments.length;
  var i__8258__auto___10405 = 0;
  while (true) {
    if (i__8258__auto___10405 < len__8257__auto___10404) {
      args10401.push(arguments[i__8258__auto___10405]);
      var G__10406 = i__8258__auto___10405 + 1;
      i__8258__auto___10405 = G__10406;
      continue;
    } else;
    break;
  }
  var G__10403 = args10401.length;
  switch (G__10403) {
    case 1:
      return cljs.core.object_array.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.object_array.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10401.length)
        ].join('')
      );
  }
};
cljs.core.object_array.cljs$core$IFn$_invoke$arity$1 = function(size_or_seq) {
  if (typeof size_or_seq === 'number')
    return cljs.core.object_array.cljs$core$IFn$_invoke$arity$2(
      size_or_seq,
      null
    );
  else
    return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq);
};
cljs.core.object_array.cljs$core$IFn$_invoke$arity$2 = function(
  size,
  init_val_or_seq
) {
  var a = new Array(size);
  if (cljs.core.seq_QMARK_(init_val_or_seq)) {
    var s = cljs.core.seq(init_val_or_seq);
    var i = 0;
    var s__$1 = s;
    while (true) {
      if (s__$1 && i < size) {
        a[i] = cljs.core.first(s__$1);
        var G__10408 = i + 1;
        var G__10409 = cljs.core.next(s__$1);
        i = G__10408;
        s__$1 = G__10409;
        continue;
      } else
        return a;
      break;
    }
  } else {
    var n__8067__auto___10410 = size;
    var i_10411 = 0;
    while (true) {
      if (i_10411 < n__8067__auto___10410) {
        a[i_10411] = init_val_or_seq;
        var G__10412 = i_10411 + 1;
        i_10411 = G__10412;
        continue;
      } else;
      break;
    }
    return a;
  }
};
cljs.core.object_array.cljs$lang$maxFixedArity = 2;
cljs.core.bounded_count = function cljs$core$bounded_count(n, coll) {
  if (cljs.core.counted_QMARK_(coll))
    return cljs.core.count(coll);
  else {
    var i = 0;
    var s = cljs.core.seq(coll);
    while (true) {
      if (!(s == null) && i < n) {
        var G__10413 = i + 1;
        var G__10414 = cljs.core.next(s);
        i = G__10413;
        s = G__10414;
        continue;
      } else
        return i;
      break;
    }
  }
};
cljs.core.spread = function cljs$core$spread(arglist) {
  if (arglist == null)
    return null;
  else if (cljs.core.next(arglist) == null)
    return cljs.core.seq(cljs.core.first(arglist));
  else
    return cljs.core.cons(
      cljs.core.first(arglist),
      (function() {
        var G__10416 = cljs.core.next(arglist);
        return cljs.core.spread.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.spread.cljs$core$IFn$_invoke$arity$1(G__10416)
          : cljs.core.spread.call(null, G__10416);
      })()
    );
};
cljs.core.concat = function cljs$core$concat(var_args) {
  var args10417 = [];
  var len__8257__auto___10429 = arguments.length;
  var i__8258__auto___10430 = 0;
  while (true) {
    if (i__8258__auto___10430 < len__8257__auto___10429) {
      args10417.push(arguments[i__8258__auto___10430]);
      var G__10431 = i__8258__auto___10430 + 1;
      i__8258__auto___10430 = G__10431;
      continue;
    } else;
    break;
  }
  var G__10422 = args10417.length;
  switch (G__10422) {
    case 0:
      return cljs.core.concat.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.concat.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10417.slice(2),
        0,
        null
      );
      return cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.concat.cljs$core$IFn$_invoke$arity$0 = function() {
  return new cljs.core.LazySeq(
    null,
    function() {
      return null;
    },
    null,
    null
  );
};
cljs.core.concat.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return new cljs.core.LazySeq(
    null,
    function() {
      return x;
    },
    null,
    null
  );
};
cljs.core.concat.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var s = cljs.core.seq(x);
      if (s)
        if (cljs.core.chunked_seq_QMARK_(s))
          return cljs.core.chunk_cons(
            cljs.core.chunk_first(s),
            cljs.core.concat.cljs$core$IFn$_invoke$arity$2(
              cljs.core.chunk_rest(s),
              y
            )
          );
        else
          return cljs.core.cons(
            cljs.core.first(s),
            cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.rest(s), y)
          );
      else
        return y;
    },
    null,
    null
  );
};
cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic = function(x, y, zs) {
  var cat = function cljs$core$cat(xys, zs__$1) {
    return new cljs.core.LazySeq(
      null,
      function() {
        var xys__$1 = cljs.core.seq(xys);
        if (xys__$1)
          if (cljs.core.chunked_seq_QMARK_(xys__$1))
            return cljs.core.chunk_cons(
              cljs.core.chunk_first(xys__$1),
              cljs$core$cat(cljs.core.chunk_rest(xys__$1), zs__$1)
            );
          else
            return cljs.core.cons(
              cljs.core.first(xys__$1),
              cljs$core$cat(cljs.core.rest(xys__$1), zs__$1)
            );
        else if (cljs.core.truth_(zs__$1))
          return cljs$core$cat(cljs.core.first(zs__$1), cljs.core.next(zs__$1));
        else
          return null;
      },
      null,
      null
    );
  };
  return cat(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(x, y), zs);
};
cljs.core.concat.cljs$lang$applyTo = function(seq10418) {
  var G__10419 = cljs.core.first(seq10418);
  var seq10418__$1 = cljs.core.next(seq10418);
  var G__10420 = cljs.core.first(seq10418__$1);
  var seq10418__$2 = cljs.core.next(seq10418__$1);
  return cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic(
    G__10419,
    G__10420,
    seq10418__$2
  );
};
cljs.core.concat.cljs$lang$maxFixedArity = 2;
cljs.core.list_STAR_ = function cljs$core$list_STAR_(var_args) {
  var args10433 = [];
  var len__8257__auto___10441 = arguments.length;
  var i__8258__auto___10442 = 0;
  while (true) {
    if (i__8258__auto___10442 < len__8257__auto___10441) {
      args10433.push(arguments[i__8258__auto___10442]);
      var G__10443 = i__8258__auto___10442 + 1;
      i__8258__auto___10442 = G__10443;
      continue;
    } else;
    break;
  }
  var G__10440 = args10433.length;
  switch (G__10440) {
    case 1:
      return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10433.slice(4),
        0,
        null
      );
      return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        argseq__8276__auto__
      );
  }
};
cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1 = function(args) {
  return cljs.core.seq(args);
};
cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2 = function(a, args) {
  return cljs.core.cons(a, args);
};
cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3 = function(a, b, args) {
  return cljs.core.cons(a, cljs.core.cons(b, args));
};
cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4 = function(a, b, c, args) {
  return cljs.core.cons(a, cljs.core.cons(b, cljs.core.cons(c, args)));
};
cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic = function(
  a,
  b,
  c,
  d,
  more
) {
  return cljs.core.cons(
    a,
    cljs.core.cons(
      b,
      cljs.core.cons(c, cljs.core.cons(d, cljs.core.spread(more)))
    )
  );
};
cljs.core.list_STAR_.cljs$lang$applyTo = function(seq10434) {
  var G__10435 = cljs.core.first(seq10434);
  var seq10434__$1 = cljs.core.next(seq10434);
  var G__10436 = cljs.core.first(seq10434__$1);
  var seq10434__$2 = cljs.core.next(seq10434__$1);
  var G__10437 = cljs.core.first(seq10434__$2);
  var seq10434__$3 = cljs.core.next(seq10434__$2);
  var G__10438 = cljs.core.first(seq10434__$3);
  var seq10434__$4 = cljs.core.next(seq10434__$3);
  return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic(
    G__10435,
    G__10436,
    G__10437,
    G__10438,
    seq10434__$4
  );
};
cljs.core.list_STAR_.cljs$lang$maxFixedArity = 4;
cljs.core.transient$ = function cljs$core$transient(coll) {
  return cljs.core._as_transient(coll);
};
cljs.core.persistent_BANG_ = function cljs$core$persistent_BANG_(tcoll) {
  return cljs.core._persistent_BANG_(tcoll);
};
cljs.core.conj_BANG_ = function cljs$core$conj_BANG_(var_args) {
  var args10445 = [];
  var len__8257__auto___10451 = arguments.length;
  var i__8258__auto___10452 = 0;
  while (true) {
    if (i__8258__auto___10452 < len__8257__auto___10451) {
      args10445.push(arguments[i__8258__auto___10452]);
      var G__10453 = i__8258__auto___10452 + 1;
      i__8258__auto___10452 = G__10453;
      continue;
    } else;
    break;
  }
  var G__10450 = args10445.length;
  switch (G__10450) {
    case 0:
      return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10445.slice(2),
        0,
        null
      );
      return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0 = function() {
  return cljs.core.transient$(cljs.core.PersistentVector.EMPTY);
};
cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1 = function(tcoll) {
  return tcoll;
};
cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2 = function(tcoll, val) {
  return cljs.core._conj_BANG_(tcoll, val);
};
cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic = function(
  tcoll,
  val,
  vals
) {
  while (true) {
    var ntcoll = cljs.core._conj_BANG_(tcoll, val);
    if (cljs.core.truth_(vals)) {
      var G__10455 = ntcoll;
      var G__10456 = cljs.core.first(vals);
      var G__10457 = cljs.core.next(vals);
      tcoll = G__10455;
      val = G__10456;
      vals = G__10457;
      continue;
    } else
      return ntcoll;
    break;
  }
};
cljs.core.conj_BANG_.cljs$lang$applyTo = function(seq10446) {
  var G__10447 = cljs.core.first(seq10446);
  var seq10446__$1 = cljs.core.next(seq10446);
  var G__10448 = cljs.core.first(seq10446__$1);
  var seq10446__$2 = cljs.core.next(seq10446__$1);
  return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic(
    G__10447,
    G__10448,
    seq10446__$2
  );
};
cljs.core.conj_BANG_.cljs$lang$maxFixedArity = 2;
cljs.core.assoc_BANG_ = function cljs$core$assoc_BANG_(var_args) {
  var args10458 = [];
  var len__8257__auto___10465 = arguments.length;
  var i__8258__auto___10466 = 0;
  while (true) {
    if (i__8258__auto___10466 < len__8257__auto___10465) {
      args10458.push(arguments[i__8258__auto___10466]);
      var G__10467 = i__8258__auto___10466 + 1;
      i__8258__auto___10466 = G__10467;
      continue;
    } else;
    break;
  }
  var G__10464 = args10458.length;
  switch (G__10464) {
    case 3:
      return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10458.slice(3),
        0,
        null
      );
      return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3 = function(
  tcoll,
  key,
  val
) {
  return cljs.core._assoc_BANG_(tcoll, key, val);
};
cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = function(
  tcoll,
  key,
  val,
  kvs
) {
  while (true) {
    var ntcoll = cljs.core._assoc_BANG_(tcoll, key, val);
    if (cljs.core.truth_(kvs)) {
      var G__10469 = ntcoll;
      var G__10470 = cljs.core.first(kvs);
      var G__10471 = cljs.core.second(kvs);
      var G__10472 = cljs.core.nnext(kvs);
      tcoll = G__10469;
      key = G__10470;
      val = G__10471;
      kvs = G__10472;
      continue;
    } else
      return ntcoll;
    break;
  }
};
cljs.core.assoc_BANG_.cljs$lang$applyTo = function(seq10459) {
  var G__10460 = cljs.core.first(seq10459);
  var seq10459__$1 = cljs.core.next(seq10459);
  var G__10461 = cljs.core.first(seq10459__$1);
  var seq10459__$2 = cljs.core.next(seq10459__$1);
  var G__10462 = cljs.core.first(seq10459__$2);
  var seq10459__$3 = cljs.core.next(seq10459__$2);
  return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic(
    G__10460,
    G__10461,
    G__10462,
    seq10459__$3
  );
};
cljs.core.assoc_BANG_.cljs$lang$maxFixedArity = 3;
cljs.core.dissoc_BANG_ = function cljs$core$dissoc_BANG_(var_args) {
  var args10473 = [];
  var len__8257__auto___10479 = arguments.length;
  var i__8258__auto___10480 = 0;
  while (true) {
    if (i__8258__auto___10480 < len__8257__auto___10479) {
      args10473.push(arguments[i__8258__auto___10480]);
      var G__10481 = i__8258__auto___10480 + 1;
      i__8258__auto___10480 = G__10481;
      continue;
    } else;
    break;
  }
  var G__10478 = args10473.length;
  switch (G__10478) {
    case 2:
      return cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10473.slice(2),
        0,
        null
      );
      return cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 = function(tcoll, key) {
  return cljs.core._dissoc_BANG_(tcoll, key);
};
cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = function(
  tcoll,
  key,
  ks
) {
  while (true) {
    var ntcoll = cljs.core._dissoc_BANG_(tcoll, key);
    if (cljs.core.truth_(ks)) {
      var G__10483 = ntcoll;
      var G__10484 = cljs.core.first(ks);
      var G__10485 = cljs.core.next(ks);
      tcoll = G__10483;
      key = G__10484;
      ks = G__10485;
      continue;
    } else
      return ntcoll;
    break;
  }
};
cljs.core.dissoc_BANG_.cljs$lang$applyTo = function(seq10474) {
  var G__10475 = cljs.core.first(seq10474);
  var seq10474__$1 = cljs.core.next(seq10474);
  var G__10476 = cljs.core.first(seq10474__$1);
  var seq10474__$2 = cljs.core.next(seq10474__$1);
  return cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic(
    G__10475,
    G__10476,
    seq10474__$2
  );
};
cljs.core.dissoc_BANG_.cljs$lang$maxFixedArity = 2;
cljs.core.pop_BANG_ = function cljs$core$pop_BANG_(tcoll) {
  return cljs.core._pop_BANG_(tcoll);
};
cljs.core.disj_BANG_ = function cljs$core$disj_BANG_(var_args) {
  var args10486 = [];
  var len__8257__auto___10492 = arguments.length;
  var i__8258__auto___10493 = 0;
  while (true) {
    if (i__8258__auto___10493 < len__8257__auto___10492) {
      args10486.push(arguments[i__8258__auto___10493]);
      var G__10494 = i__8258__auto___10493 + 1;
      i__8258__auto___10493 = G__10494;
      continue;
    } else;
    break;
  }
  var G__10491 = args10486.length;
  switch (G__10491) {
    case 2:
      return cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10486.slice(2),
        0,
        null
      );
      return cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2 = function(tcoll, val) {
  return cljs.core._disjoin_BANG_(tcoll, val);
};
cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic = function(
  tcoll,
  val,
  vals
) {
  while (true) {
    var ntcoll = cljs.core._disjoin_BANG_(tcoll, val);
    if (cljs.core.truth_(vals)) {
      var G__10496 = ntcoll;
      var G__10497 = cljs.core.first(vals);
      var G__10498 = cljs.core.next(vals);
      tcoll = G__10496;
      val = G__10497;
      vals = G__10498;
      continue;
    } else
      return ntcoll;
    break;
  }
};
cljs.core.disj_BANG_.cljs$lang$applyTo = function(seq10487) {
  var G__10488 = cljs.core.first(seq10487);
  var seq10487__$1 = cljs.core.next(seq10487);
  var G__10489 = cljs.core.first(seq10487__$1);
  var seq10487__$2 = cljs.core.next(seq10487__$1);
  return cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic(
    G__10488,
    G__10489,
    seq10487__$2
  );
};
cljs.core.disj_BANG_.cljs$lang$maxFixedArity = 2;
cljs.core.apply_to = function cljs$core$apply_to(f, argc, args) {
  var args__$1 = cljs.core.seq(args);
  if (argc === 0)
    return f.cljs$core$IFn$_invoke$arity$0
      ? f.cljs$core$IFn$_invoke$arity$0()
      : f.call(null);
  else {
    var a8111 = cljs.core._first(args__$1);
    var args__$2 = cljs.core._rest(args__$1);
    if (argc === 1)
      if (f.cljs$core$IFn$_invoke$arity$1)
        return f.cljs$core$IFn$_invoke$arity$1(a8111);
      else
        return f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(a8111)
          : f.call(null, a8111);
    else {
      var b8112 = cljs.core._first(args__$2);
      var args__$3 = cljs.core._rest(args__$2);
      if (argc === 2)
        if (f.cljs$core$IFn$_invoke$arity$2)
          return f.cljs$core$IFn$_invoke$arity$2(a8111, b8112);
        else
          return f.cljs$core$IFn$_invoke$arity$2
            ? f.cljs$core$IFn$_invoke$arity$2(a8111, b8112)
            : f.call(null, a8111, b8112);
      else {
        var c8113 = cljs.core._first(args__$3);
        var args__$4 = cljs.core._rest(args__$3);
        if (argc === 3)
          if (f.cljs$core$IFn$_invoke$arity$3)
            return f.cljs$core$IFn$_invoke$arity$3(a8111, b8112, c8113);
          else
            return f.cljs$core$IFn$_invoke$arity$3
              ? f.cljs$core$IFn$_invoke$arity$3(a8111, b8112, c8113)
              : f.call(null, a8111, b8112, c8113);
        else {
          var d8114 = cljs.core._first(args__$4);
          var args__$5 = cljs.core._rest(args__$4);
          if (argc === 4)
            if (f.cljs$core$IFn$_invoke$arity$4)
              return f.cljs$core$IFn$_invoke$arity$4(
                a8111,
                b8112,
                c8113,
                d8114
              );
            else
              return f.cljs$core$IFn$_invoke$arity$4
                ? f.cljs$core$IFn$_invoke$arity$4(a8111, b8112, c8113, d8114)
                : f.call(null, a8111, b8112, c8113, d8114);
          else {
            var e8115 = cljs.core._first(args__$5);
            var args__$6 = cljs.core._rest(args__$5);
            if (argc === 5)
              if (f.cljs$core$IFn$_invoke$arity$5)
                return f.cljs$core$IFn$_invoke$arity$5(
                  a8111,
                  b8112,
                  c8113,
                  d8114,
                  e8115
                );
              else
                return f.cljs$core$IFn$_invoke$arity$5
                  ? f.cljs$core$IFn$_invoke$arity$5(
                      a8111,
                      b8112,
                      c8113,
                      d8114,
                      e8115
                    )
                  : f.call(null, a8111, b8112, c8113, d8114, e8115);
            else {
              var f8116 = cljs.core._first(args__$6);
              var args__$7 = cljs.core._rest(args__$6);
              if (argc === 6)
                if (f.cljs$core$IFn$_invoke$arity$6)
                  return f.cljs$core$IFn$_invoke$arity$6(
                    a8111,
                    b8112,
                    c8113,
                    d8114,
                    e8115,
                    f8116
                  );
                else
                  return f.cljs$core$IFn$_invoke$arity$6
                    ? f.cljs$core$IFn$_invoke$arity$6(
                        a8111,
                        b8112,
                        c8113,
                        d8114,
                        e8115,
                        f8116
                      )
                    : f.call(null, a8111, b8112, c8113, d8114, e8115, f8116);
              else {
                var g8117 = cljs.core._first(args__$7);
                var args__$8 = cljs.core._rest(args__$7);
                if (argc === 7)
                  if (f.cljs$core$IFn$_invoke$arity$7)
                    return f.cljs$core$IFn$_invoke$arity$7(
                      a8111,
                      b8112,
                      c8113,
                      d8114,
                      e8115,
                      f8116,
                      g8117
                    );
                  else
                    return f.cljs$core$IFn$_invoke$arity$7
                      ? f.cljs$core$IFn$_invoke$arity$7(
                          a8111,
                          b8112,
                          c8113,
                          d8114,
                          e8115,
                          f8116,
                          g8117
                        )
                      : f.call(
                          null,
                          a8111,
                          b8112,
                          c8113,
                          d8114,
                          e8115,
                          f8116,
                          g8117
                        );
                else {
                  var h8118 = cljs.core._first(args__$8);
                  var args__$9 = cljs.core._rest(args__$8);
                  if (argc === 8)
                    if (f.cljs$core$IFn$_invoke$arity$8)
                      return f.cljs$core$IFn$_invoke$arity$8(
                        a8111,
                        b8112,
                        c8113,
                        d8114,
                        e8115,
                        f8116,
                        g8117,
                        h8118
                      );
                    else
                      return f.cljs$core$IFn$_invoke$arity$8
                        ? f.cljs$core$IFn$_invoke$arity$8(
                            a8111,
                            b8112,
                            c8113,
                            d8114,
                            e8115,
                            f8116,
                            g8117,
                            h8118
                          )
                        : f.call(
                            null,
                            a8111,
                            b8112,
                            c8113,
                            d8114,
                            e8115,
                            f8116,
                            g8117,
                            h8118
                          );
                  else {
                    var i8119 = cljs.core._first(args__$9);
                    var args__$10 = cljs.core._rest(args__$9);
                    if (argc === 9)
                      if (f.cljs$core$IFn$_invoke$arity$9)
                        return f.cljs$core$IFn$_invoke$arity$9(
                          a8111,
                          b8112,
                          c8113,
                          d8114,
                          e8115,
                          f8116,
                          g8117,
                          h8118,
                          i8119
                        );
                      else
                        return f.cljs$core$IFn$_invoke$arity$9
                          ? f.cljs$core$IFn$_invoke$arity$9(
                              a8111,
                              b8112,
                              c8113,
                              d8114,
                              e8115,
                              f8116,
                              g8117,
                              h8118,
                              i8119
                            )
                          : f.call(
                              null,
                              a8111,
                              b8112,
                              c8113,
                              d8114,
                              e8115,
                              f8116,
                              g8117,
                              h8118,
                              i8119
                            );
                    else {
                      var j8120 = cljs.core._first(args__$10);
                      var args__$11 = cljs.core._rest(args__$10);
                      if (argc === 10)
                        if (f.cljs$core$IFn$_invoke$arity$10)
                          return f.cljs$core$IFn$_invoke$arity$10(
                            a8111,
                            b8112,
                            c8113,
                            d8114,
                            e8115,
                            f8116,
                            g8117,
                            h8118,
                            i8119,
                            j8120
                          );
                        else
                          return f.cljs$core$IFn$_invoke$arity$10
                            ? f.cljs$core$IFn$_invoke$arity$10(
                                a8111,
                                b8112,
                                c8113,
                                d8114,
                                e8115,
                                f8116,
                                g8117,
                                h8118,
                                i8119,
                                j8120
                              )
                            : f.call(
                                null,
                                a8111,
                                b8112,
                                c8113,
                                d8114,
                                e8115,
                                f8116,
                                g8117,
                                h8118,
                                i8119,
                                j8120
                              );
                      else {
                        var k8121 = cljs.core._first(args__$11);
                        var args__$12 = cljs.core._rest(args__$11);
                        if (argc === 11)
                          if (f.cljs$core$IFn$_invoke$arity$11)
                            return f.cljs$core$IFn$_invoke$arity$11(
                              a8111,
                              b8112,
                              c8113,
                              d8114,
                              e8115,
                              f8116,
                              g8117,
                              h8118,
                              i8119,
                              j8120,
                              k8121
                            );
                          else
                            return f.cljs$core$IFn$_invoke$arity$11
                              ? f.cljs$core$IFn$_invoke$arity$11(
                                  a8111,
                                  b8112,
                                  c8113,
                                  d8114,
                                  e8115,
                                  f8116,
                                  g8117,
                                  h8118,
                                  i8119,
                                  j8120,
                                  k8121
                                )
                              : f.call(
                                  null,
                                  a8111,
                                  b8112,
                                  c8113,
                                  d8114,
                                  e8115,
                                  f8116,
                                  g8117,
                                  h8118,
                                  i8119,
                                  j8120,
                                  k8121
                                );
                        else {
                          var l8122 = cljs.core._first(args__$12);
                          var args__$13 = cljs.core._rest(args__$12);
                          if (argc === 12)
                            if (f.cljs$core$IFn$_invoke$arity$12)
                              return f.cljs$core$IFn$_invoke$arity$12(
                                a8111,
                                b8112,
                                c8113,
                                d8114,
                                e8115,
                                f8116,
                                g8117,
                                h8118,
                                i8119,
                                j8120,
                                k8121,
                                l8122
                              );
                            else
                              return f.cljs$core$IFn$_invoke$arity$12
                                ? f.cljs$core$IFn$_invoke$arity$12(
                                    a8111,
                                    b8112,
                                    c8113,
                                    d8114,
                                    e8115,
                                    f8116,
                                    g8117,
                                    h8118,
                                    i8119,
                                    j8120,
                                    k8121,
                                    l8122
                                  )
                                : f.call(
                                    null,
                                    a8111,
                                    b8112,
                                    c8113,
                                    d8114,
                                    e8115,
                                    f8116,
                                    g8117,
                                    h8118,
                                    i8119,
                                    j8120,
                                    k8121,
                                    l8122
                                  );
                          else {
                            var m8123 = cljs.core._first(args__$13);
                            var args__$14 = cljs.core._rest(args__$13);
                            if (argc === 13)
                              if (f.cljs$core$IFn$_invoke$arity$13)
                                return f.cljs$core$IFn$_invoke$arity$13(
                                  a8111,
                                  b8112,
                                  c8113,
                                  d8114,
                                  e8115,
                                  f8116,
                                  g8117,
                                  h8118,
                                  i8119,
                                  j8120,
                                  k8121,
                                  l8122,
                                  m8123
                                );
                              else
                                return f.cljs$core$IFn$_invoke$arity$13
                                  ? f.cljs$core$IFn$_invoke$arity$13(
                                      a8111,
                                      b8112,
                                      c8113,
                                      d8114,
                                      e8115,
                                      f8116,
                                      g8117,
                                      h8118,
                                      i8119,
                                      j8120,
                                      k8121,
                                      l8122,
                                      m8123
                                    )
                                  : f.call(
                                      null,
                                      a8111,
                                      b8112,
                                      c8113,
                                      d8114,
                                      e8115,
                                      f8116,
                                      g8117,
                                      h8118,
                                      i8119,
                                      j8120,
                                      k8121,
                                      l8122,
                                      m8123
                                    );
                            else {
                              var n8124 = cljs.core._first(args__$14);
                              var args__$15 = cljs.core._rest(args__$14);
                              if (argc === 14)
                                if (f.cljs$core$IFn$_invoke$arity$14)
                                  return f.cljs$core$IFn$_invoke$arity$14(
                                    a8111,
                                    b8112,
                                    c8113,
                                    d8114,
                                    e8115,
                                    f8116,
                                    g8117,
                                    h8118,
                                    i8119,
                                    j8120,
                                    k8121,
                                    l8122,
                                    m8123,
                                    n8124
                                  );
                                else
                                  return f.cljs$core$IFn$_invoke$arity$14
                                    ? f.cljs$core$IFn$_invoke$arity$14(
                                        a8111,
                                        b8112,
                                        c8113,
                                        d8114,
                                        e8115,
                                        f8116,
                                        g8117,
                                        h8118,
                                        i8119,
                                        j8120,
                                        k8121,
                                        l8122,
                                        m8123,
                                        n8124
                                      )
                                    : f.call(
                                        null,
                                        a8111,
                                        b8112,
                                        c8113,
                                        d8114,
                                        e8115,
                                        f8116,
                                        g8117,
                                        h8118,
                                        i8119,
                                        j8120,
                                        k8121,
                                        l8122,
                                        m8123,
                                        n8124
                                      );
                              else {
                                var o8125 = cljs.core._first(args__$15);
                                var args__$16 = cljs.core._rest(args__$15);
                                if (argc === 15)
                                  if (f.cljs$core$IFn$_invoke$arity$15)
                                    return f.cljs$core$IFn$_invoke$arity$15(
                                      a8111,
                                      b8112,
                                      c8113,
                                      d8114,
                                      e8115,
                                      f8116,
                                      g8117,
                                      h8118,
                                      i8119,
                                      j8120,
                                      k8121,
                                      l8122,
                                      m8123,
                                      n8124,
                                      o8125
                                    );
                                  else
                                    return f.cljs$core$IFn$_invoke$arity$15
                                      ? f.cljs$core$IFn$_invoke$arity$15(
                                          a8111,
                                          b8112,
                                          c8113,
                                          d8114,
                                          e8115,
                                          f8116,
                                          g8117,
                                          h8118,
                                          i8119,
                                          j8120,
                                          k8121,
                                          l8122,
                                          m8123,
                                          n8124,
                                          o8125
                                        )
                                      : f.call(
                                          null,
                                          a8111,
                                          b8112,
                                          c8113,
                                          d8114,
                                          e8115,
                                          f8116,
                                          g8117,
                                          h8118,
                                          i8119,
                                          j8120,
                                          k8121,
                                          l8122,
                                          m8123,
                                          n8124,
                                          o8125
                                        );
                                else {
                                  var p8126 = cljs.core._first(args__$16);
                                  var args__$17 = cljs.core._rest(args__$16);
                                  if (argc === 16)
                                    if (f.cljs$core$IFn$_invoke$arity$16)
                                      return f.cljs$core$IFn$_invoke$arity$16(
                                        a8111,
                                        b8112,
                                        c8113,
                                        d8114,
                                        e8115,
                                        f8116,
                                        g8117,
                                        h8118,
                                        i8119,
                                        j8120,
                                        k8121,
                                        l8122,
                                        m8123,
                                        n8124,
                                        o8125,
                                        p8126
                                      );
                                    else
                                      return f.cljs$core$IFn$_invoke$arity$16
                                        ? f.cljs$core$IFn$_invoke$arity$16(
                                            a8111,
                                            b8112,
                                            c8113,
                                            d8114,
                                            e8115,
                                            f8116,
                                            g8117,
                                            h8118,
                                            i8119,
                                            j8120,
                                            k8121,
                                            l8122,
                                            m8123,
                                            n8124,
                                            o8125,
                                            p8126
                                          )
                                        : f.call(
                                            null,
                                            a8111,
                                            b8112,
                                            c8113,
                                            d8114,
                                            e8115,
                                            f8116,
                                            g8117,
                                            h8118,
                                            i8119,
                                            j8120,
                                            k8121,
                                            l8122,
                                            m8123,
                                            n8124,
                                            o8125,
                                            p8126
                                          );
                                  else {
                                    var q8127 = cljs.core._first(args__$17);
                                    var args__$18 = cljs.core._rest(args__$17);
                                    if (argc === 17)
                                      if (f.cljs$core$IFn$_invoke$arity$17)
                                        return f.cljs$core$IFn$_invoke$arity$17(
                                          a8111,
                                          b8112,
                                          c8113,
                                          d8114,
                                          e8115,
                                          f8116,
                                          g8117,
                                          h8118,
                                          i8119,
                                          j8120,
                                          k8121,
                                          l8122,
                                          m8123,
                                          n8124,
                                          o8125,
                                          p8126,
                                          q8127
                                        );
                                      else
                                        return f.cljs$core$IFn$_invoke$arity$17
                                          ? f.cljs$core$IFn$_invoke$arity$17(
                                              a8111,
                                              b8112,
                                              c8113,
                                              d8114,
                                              e8115,
                                              f8116,
                                              g8117,
                                              h8118,
                                              i8119,
                                              j8120,
                                              k8121,
                                              l8122,
                                              m8123,
                                              n8124,
                                              o8125,
                                              p8126,
                                              q8127
                                            )
                                          : f.call(
                                              null,
                                              a8111,
                                              b8112,
                                              c8113,
                                              d8114,
                                              e8115,
                                              f8116,
                                              g8117,
                                              h8118,
                                              i8119,
                                              j8120,
                                              k8121,
                                              l8122,
                                              m8123,
                                              n8124,
                                              o8125,
                                              p8126,
                                              q8127
                                            );
                                    else {
                                      var r8128 = cljs.core._first(args__$18);
                                      var args__$19 = cljs.core._rest(
                                        args__$18
                                      );
                                      if (argc === 18)
                                        if (f.cljs$core$IFn$_invoke$arity$18)
                                          return f.cljs$core$IFn$_invoke$arity$18(
                                            a8111,
                                            b8112,
                                            c8113,
                                            d8114,
                                            e8115,
                                            f8116,
                                            g8117,
                                            h8118,
                                            i8119,
                                            j8120,
                                            k8121,
                                            l8122,
                                            m8123,
                                            n8124,
                                            o8125,
                                            p8126,
                                            q8127,
                                            r8128
                                          );
                                        else
                                          return f.cljs$core$IFn$_invoke$arity$18
                                            ? f.cljs$core$IFn$_invoke$arity$18(
                                                a8111,
                                                b8112,
                                                c8113,
                                                d8114,
                                                e8115,
                                                f8116,
                                                g8117,
                                                h8118,
                                                i8119,
                                                j8120,
                                                k8121,
                                                l8122,
                                                m8123,
                                                n8124,
                                                o8125,
                                                p8126,
                                                q8127,
                                                r8128
                                              )
                                            : f.call(
                                                null,
                                                a8111,
                                                b8112,
                                                c8113,
                                                d8114,
                                                e8115,
                                                f8116,
                                                g8117,
                                                h8118,
                                                i8119,
                                                j8120,
                                                k8121,
                                                l8122,
                                                m8123,
                                                n8124,
                                                o8125,
                                                p8126,
                                                q8127,
                                                r8128
                                              );
                                      else {
                                        var s8129 = cljs.core._first(args__$19);
                                        var args__$20 = cljs.core._rest(
                                          args__$19
                                        );
                                        if (argc === 19)
                                          if (f.cljs$core$IFn$_invoke$arity$19)
                                            return f.cljs$core$IFn$_invoke$arity$19(
                                              a8111,
                                              b8112,
                                              c8113,
                                              d8114,
                                              e8115,
                                              f8116,
                                              g8117,
                                              h8118,
                                              i8119,
                                              j8120,
                                              k8121,
                                              l8122,
                                              m8123,
                                              n8124,
                                              o8125,
                                              p8126,
                                              q8127,
                                              r8128,
                                              s8129
                                            );
                                          else
                                            return f.cljs$core$IFn$_invoke$arity$19
                                              ? f.cljs$core$IFn$_invoke$arity$19(
                                                  a8111,
                                                  b8112,
                                                  c8113,
                                                  d8114,
                                                  e8115,
                                                  f8116,
                                                  g8117,
                                                  h8118,
                                                  i8119,
                                                  j8120,
                                                  k8121,
                                                  l8122,
                                                  m8123,
                                                  n8124,
                                                  o8125,
                                                  p8126,
                                                  q8127,
                                                  r8128,
                                                  s8129
                                                )
                                              : f.call(
                                                  null,
                                                  a8111,
                                                  b8112,
                                                  c8113,
                                                  d8114,
                                                  e8115,
                                                  f8116,
                                                  g8117,
                                                  h8118,
                                                  i8119,
                                                  j8120,
                                                  k8121,
                                                  l8122,
                                                  m8123,
                                                  n8124,
                                                  o8125,
                                                  p8126,
                                                  q8127,
                                                  r8128,
                                                  s8129
                                                );
                                        else {
                                          var t8130 = cljs.core._first(
                                            args__$20
                                          );
                                          var args__$21 = cljs.core._rest(
                                            args__$20
                                          );
                                          if (argc === 20)
                                            if (
                                              f.cljs$core$IFn$_invoke$arity$20
                                            )
                                              return f.cljs$core$IFn$_invoke$arity$20(
                                                a8111,
                                                b8112,
                                                c8113,
                                                d8114,
                                                e8115,
                                                f8116,
                                                g8117,
                                                h8118,
                                                i8119,
                                                j8120,
                                                k8121,
                                                l8122,
                                                m8123,
                                                n8124,
                                                o8125,
                                                p8126,
                                                q8127,
                                                r8128,
                                                s8129,
                                                t8130
                                              );
                                            else
                                              return f.cljs$core$IFn$_invoke$arity$20
                                                ? f.cljs$core$IFn$_invoke$arity$20(
                                                    a8111,
                                                    b8112,
                                                    c8113,
                                                    d8114,
                                                    e8115,
                                                    f8116,
                                                    g8117,
                                                    h8118,
                                                    i8119,
                                                    j8120,
                                                    k8121,
                                                    l8122,
                                                    m8123,
                                                    n8124,
                                                    o8125,
                                                    p8126,
                                                    q8127,
                                                    r8128,
                                                    s8129,
                                                    t8130
                                                  )
                                                : f.call(
                                                    null,
                                                    a8111,
                                                    b8112,
                                                    c8113,
                                                    d8114,
                                                    e8115,
                                                    f8116,
                                                    g8117,
                                                    h8118,
                                                    i8119,
                                                    j8120,
                                                    k8121,
                                                    l8122,
                                                    m8123,
                                                    n8124,
                                                    o8125,
                                                    p8126,
                                                    q8127,
                                                    r8128,
                                                    s8129,
                                                    t8130
                                                  );
                                          else
                                            throw new Error(
                                              'Only up to 20 arguments supported on functions'
                                            );
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
};
cljs.core.apply = function cljs$core$apply(var_args) {
  var args10499 = [];
  var len__8257__auto___10508 = arguments.length;
  var i__8258__auto___10509 = 0;
  while (true) {
    if (i__8258__auto___10509 < len__8257__auto___10508) {
      args10499.push(arguments[i__8258__auto___10509]);
      var G__10510 = i__8258__auto___10509 + 1;
      i__8258__auto___10509 = G__10510;
      continue;
    } else;
    break;
  }
  var G__10507 = args10499.length;
  switch (G__10507) {
    case 2:
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10499.slice(5),
        0,
        null
      );
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        argseq__8276__auto__
      );
  }
};
cljs.core.apply.cljs$core$IFn$_invoke$arity$2 = function(f, args) {
  var fixed_arity = f.cljs$lang$maxFixedArity;
  if (f.cljs$lang$applyTo) {
    var bc = cljs.core.bounded_count(fixed_arity + 1, args);
    if (bc <= fixed_arity) return cljs.core.apply_to(f, bc, args);
    else return f.cljs$lang$applyTo(args);
  } else
    return f.apply(f, cljs.core.to_array(args));
};
cljs.core.apply.cljs$core$IFn$_invoke$arity$3 = function(f, x, args) {
  var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2(x, args);
  var fixed_arity = f.cljs$lang$maxFixedArity;
  if (f.cljs$lang$applyTo) {
    var bc = cljs.core.bounded_count(fixed_arity + 1, arglist);
    if (bc <= fixed_arity) return cljs.core.apply_to(f, bc, arglist);
    else return f.cljs$lang$applyTo(arglist);
  } else
    return f.apply(f, cljs.core.to_array(arglist));
};
cljs.core.apply.cljs$core$IFn$_invoke$arity$4 = function(f, x, y, args) {
  var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3(x, y, args);
  var fixed_arity = f.cljs$lang$maxFixedArity;
  if (f.cljs$lang$applyTo) {
    var bc = cljs.core.bounded_count(fixed_arity + 1, arglist);
    if (bc <= fixed_arity) return cljs.core.apply_to(f, bc, arglist);
    else return f.cljs$lang$applyTo(arglist);
  } else
    return f.apply(f, cljs.core.to_array(arglist));
};
cljs.core.apply.cljs$core$IFn$_invoke$arity$5 = function(f, x, y, z, args) {
  var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(
    x,
    y,
    z,
    args
  );
  var fixed_arity = f.cljs$lang$maxFixedArity;
  if (f.cljs$lang$applyTo) {
    var bc = cljs.core.bounded_count(fixed_arity + 1, arglist);
    if (bc <= fixed_arity) return cljs.core.apply_to(f, bc, arglist);
    else return f.cljs$lang$applyTo(arglist);
  } else
    return f.apply(f, cljs.core.to_array(arglist));
};
cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic = function(
  f,
  a,
  b,
  c,
  d,
  args
) {
  var arglist = cljs.core.cons(
    a,
    cljs.core.cons(
      b,
      cljs.core.cons(c, cljs.core.cons(d, cljs.core.spread(args)))
    )
  );
  var fixed_arity = f.cljs$lang$maxFixedArity;
  if (f.cljs$lang$applyTo) {
    var bc = cljs.core.bounded_count(fixed_arity + 1, arglist);
    if (bc <= fixed_arity) return cljs.core.apply_to(f, bc, arglist);
    else return f.cljs$lang$applyTo(arglist);
  } else
    return f.apply(f, cljs.core.to_array(arglist));
};
cljs.core.apply.cljs$lang$applyTo = function(seq10500) {
  var G__10501 = cljs.core.first(seq10500);
  var seq10500__$1 = cljs.core.next(seq10500);
  var G__10502 = cljs.core.first(seq10500__$1);
  var seq10500__$2 = cljs.core.next(seq10500__$1);
  var G__10503 = cljs.core.first(seq10500__$2);
  var seq10500__$3 = cljs.core.next(seq10500__$2);
  var G__10504 = cljs.core.first(seq10500__$3);
  var seq10500__$4 = cljs.core.next(seq10500__$3);
  var G__10505 = cljs.core.first(seq10500__$4);
  var seq10500__$5 = cljs.core.next(seq10500__$4);
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
    G__10501,
    G__10502,
    G__10503,
    G__10504,
    G__10505,
    seq10500__$5
  );
};
cljs.core.apply.cljs$lang$maxFixedArity = 5;
cljs.core.vary_meta = function cljs$core$vary_meta(var_args) {
  var args10512 = [];
  var len__8257__auto___10537 = arguments.length;
  var i__8258__auto___10538 = 0;
  while (true) {
    if (i__8258__auto___10538 < len__8257__auto___10537) {
      args10512.push(arguments[i__8258__auto___10538]);
      var G__10539 = i__8258__auto___10538 + 1;
      i__8258__auto___10538 = G__10539;
      continue;
    } else;
    break;
  }
  var G__10521 = args10512.length;
  switch (G__10521) {
    case 2:
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    case 6:
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10512.slice(6),
        0,
        null
      );
      return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        argseq__8276__auto__
      );
  }
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2 = function(obj, f) {
  return cljs.core.with_meta(
    obj,
    (function() {
      var G__10522 = cljs.core.meta(obj);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10522)
        : f.call(null, G__10522);
    })()
  );
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3 = function(obj, f, a) {
  return cljs.core.with_meta(
    obj,
    (function() {
      var G__10523 = cljs.core.meta(obj);
      var G__10524 = a;
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(G__10523, G__10524)
        : f.call(null, G__10523, G__10524);
    })()
  );
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4 = function(obj, f, a, b) {
  return cljs.core.with_meta(
    obj,
    (function() {
      var G__10525 = cljs.core.meta(obj);
      var G__10526 = a;
      var G__10527 = b;
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(G__10525, G__10526, G__10527)
        : f.call(null, G__10525, G__10526, G__10527);
    })()
  );
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5 = function(obj, f, a, b, c) {
  return cljs.core.with_meta(
    obj,
    (function() {
      var G__10528 = cljs.core.meta(obj);
      var G__10529 = a;
      var G__10530 = b;
      var G__10531 = c;
      return f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(
            G__10528,
            G__10529,
            G__10530,
            G__10531
          )
        : f.call(null, G__10528, G__10529, G__10530, G__10531);
    })()
  );
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6 = function(
  obj,
  f,
  a,
  b,
  c,
  d
) {
  return cljs.core.with_meta(
    obj,
    (function() {
      var G__10532 = cljs.core.meta(obj);
      var G__10533 = a;
      var G__10534 = b;
      var G__10535 = c;
      var G__10536 = d;
      return f.cljs$core$IFn$_invoke$arity$5
        ? f.cljs$core$IFn$_invoke$arity$5(
            G__10532,
            G__10533,
            G__10534,
            G__10535,
            G__10536
          )
        : f.call(null, G__10532, G__10533, G__10534, G__10535, G__10536);
    })()
  );
};
cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic = function(
  obj,
  f,
  a,
  b,
  c,
  d,
  args
) {
  return cljs.core.with_meta(
    obj,
    cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
      f,
      cljs.core.meta(obj),
      a,
      b,
      c,
      cljs.core.array_seq([d, args], 0)
    )
  );
};
cljs.core.vary_meta.cljs$lang$applyTo = function(seq10513) {
  var G__10514 = cljs.core.first(seq10513);
  var seq10513__$1 = cljs.core.next(seq10513);
  var G__10515 = cljs.core.first(seq10513__$1);
  var seq10513__$2 = cljs.core.next(seq10513__$1);
  var G__10516 = cljs.core.first(seq10513__$2);
  var seq10513__$3 = cljs.core.next(seq10513__$2);
  var G__10517 = cljs.core.first(seq10513__$3);
  var seq10513__$4 = cljs.core.next(seq10513__$3);
  var G__10518 = cljs.core.first(seq10513__$4);
  var seq10513__$5 = cljs.core.next(seq10513__$4);
  var G__10519 = cljs.core.first(seq10513__$5);
  var seq10513__$6 = cljs.core.next(seq10513__$5);
  return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic(
    G__10514,
    G__10515,
    G__10516,
    G__10517,
    G__10518,
    G__10519,
    seq10513__$6
  );
};
cljs.core.vary_meta.cljs$lang$maxFixedArity = 6;
cljs.core.not_EQ_ = function cljs$core$not_EQ_(var_args) {
  var args10541 = [];
  var len__8257__auto___10547 = arguments.length;
  var i__8258__auto___10548 = 0;
  while (true) {
    if (i__8258__auto___10548 < len__8257__auto___10547) {
      args10541.push(arguments[i__8258__auto___10548]);
      var G__10549 = i__8258__auto___10548 + 1;
      i__8258__auto___10548 = G__10549;
      continue;
    } else;
    break;
  }
  var G__10546 = args10541.length;
  switch (G__10546) {
    case 1:
      return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10541.slice(2),
        0,
        null
      );
      return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return false;
};
cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2 = function(x, y) {
  return !cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x, y);
};
cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic = function(x, y, more) {
  return cljs.core.not(
    cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core._EQ_, x, y, more)
  );
};
cljs.core.not_EQ_.cljs$lang$applyTo = function(seq10542) {
  var G__10543 = cljs.core.first(seq10542);
  var seq10542__$1 = cljs.core.next(seq10542);
  var G__10544 = cljs.core.first(seq10542__$1);
  var seq10542__$2 = cljs.core.next(seq10542__$1);
  return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic(
    G__10543,
    G__10544,
    seq10542__$2
  );
};
cljs.core.not_EQ_.cljs$lang$maxFixedArity = 2;
cljs.core.not_empty = function cljs$core$not_empty(coll) {
  if (cljs.core.seq(coll)) return coll;
  else return null;
};
cljs.core.nil_iter = function cljs$core$nil_iter() {
  if (typeof cljs.core.t_cljs$core10554 !== 'undefined');
  else {
    cljs.core.t_cljs$core10554 = function(meta10555) {
      this.meta10555 = meta10555;
      this.cljs$lang$protocol_mask$partition0$ = 393216;
      this.cljs$lang$protocol_mask$partition1$ = 0;
    };
    cljs.core.t_cljs$core10554.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
      _10556,
      meta10555__$1
    ) {
      var self__ = this;
      var _10556__$1 = this;
      return new cljs.core.t_cljs$core10554(meta10555__$1);
    };
    cljs.core.t_cljs$core10554.prototype.cljs$core$IMeta$_meta$arity$1 = function(
      _10556
    ) {
      var self__ = this;
      var _10556__$1 = this;
      return self__.meta10555;
    };
    cljs.core.t_cljs$core10554.prototype.hasNext = function() {
      var self__ = this;
      var _ = this;
      return false;
    };
    cljs.core.t_cljs$core10554.prototype.next = function() {
      var self__ = this;
      var _ = this;
      return new Error('No such element');
    };
    cljs.core.t_cljs$core10554.prototype.remove = function() {
      var self__ = this;
      var _ = this;
      return new Error('Unsupported operation');
    };
    cljs.core.t_cljs$core10554.getBasis = function() {
      return new cljs.core.PersistentVector(
        null,
        1,
        5,
        cljs.core.PersistentVector.EMPTY_NODE,
        [
          new cljs.core.Symbol(null, 'meta10555', 'meta10555', -915910260, null)
        ],
        null
      );
    };
    cljs.core.t_cljs$core10554.cljs$lang$type = true;
    cljs.core.t_cljs$core10554.cljs$lang$ctorStr = 'cljs.core/t_cljs$core10554';
    cljs.core.t_cljs$core10554.cljs$lang$ctorPrWriter = function(
      this__7755__auto__,
      writer__7756__auto__,
      opt__7757__auto__
    ) {
      return cljs.core._write(
        writer__7756__auto__,
        'cljs.core/t_cljs$core10554'
      );
    };
    cljs.core.__GT_t_cljs$core10554 = function cljs$core$nil_iter_$___GT_t_cljs$core10554(
      meta10555
    ) {
      return new cljs.core.t_cljs$core10554(meta10555);
    };
  }
  return new cljs.core.t_cljs$core10554(cljs.core.PersistentArrayMap.EMPTY);
};
cljs.core.StringIter = function(s, i) {
  this.s = s;
  this.i = i;
};
cljs.core.StringIter.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  return self__.i < self__.s.length;
};
cljs.core.StringIter.prototype.next = function() {
  var self__ = this;
  var _ = this;
  var ret = self__.s.charAt(self__.i);
  self__.i = self__.i + 1;
  return ret;
};
cljs.core.StringIter.prototype.remove = function() {
  var self__ = this;
  var _ = this;
  return new Error('Unsupported operation');
};
cljs.core.StringIter.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 's', 's', -948495851, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.StringIter.cljs$lang$type = true;
cljs.core.StringIter.cljs$lang$ctorStr = 'cljs.core/StringIter';
cljs.core.StringIter.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/StringIter');
};
cljs.core.__GT_StringIter = function cljs$core$__GT_StringIter(s, i) {
  return new cljs.core.StringIter(s, i);
};
cljs.core.string_iter = function cljs$core$string_iter(x) {
  return new cljs.core.StringIter(x, 0);
};
cljs.core.ArrayIter = function(arr, i) {
  this.arr = arr;
  this.i = i;
};
cljs.core.ArrayIter.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  return self__.i < self__.arr.length;
};
cljs.core.ArrayIter.prototype.next = function() {
  var self__ = this;
  var _ = this;
  var ret = self__.arr[self__.i];
  self__.i = self__.i + 1;
  return ret;
};
cljs.core.ArrayIter.prototype.remove = function() {
  var self__ = this;
  var _ = this;
  return new Error('Unsupported operation');
};
cljs.core.ArrayIter.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ArrayIter.cljs$lang$type = true;
cljs.core.ArrayIter.cljs$lang$ctorStr = 'cljs.core/ArrayIter';
cljs.core.ArrayIter.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ArrayIter');
};
cljs.core.__GT_ArrayIter = function cljs$core$__GT_ArrayIter(arr, i) {
  return new cljs.core.ArrayIter(arr, i);
};
cljs.core.array_iter = function cljs$core$array_iter(x) {
  return new cljs.core.ArrayIter(x, 0);
};
cljs.core.INIT = {};
cljs.core.START = {};
cljs.core.SeqIter = function(_seq, _next) {
  this._seq = _seq;
  this._next = _next;
};
cljs.core.SeqIter.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  if (self__._seq === cljs.core.INIT) {
    self__._seq = cljs.core.START;
    self__._next = cljs.core.seq(self__._next);
  } else if (self__._seq === self__._next)
    self__._next = cljs.core.next(self__._seq);
  else;
  return !(self__._next == null);
};
cljs.core.SeqIter.prototype.next = function() {
  var self__ = this;
  var this$ = this;
  if (!this$.hasNext())
    throw new Error('No such element');
  else {
    self__._seq = self__._next;
    return cljs.core.first(self__._next);
  }
};
cljs.core.SeqIter.prototype.remove = function() {
  var self__ = this;
  var _ = this;
  return new Error('Unsupported operation');
};
cljs.core.SeqIter.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '_seq', '_seq', -449557847, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '_next', '_next', 101877036, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.SeqIter.cljs$lang$type = true;
cljs.core.SeqIter.cljs$lang$ctorStr = 'cljs.core/SeqIter';
cljs.core.SeqIter.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/SeqIter');
};
cljs.core.__GT_SeqIter = function cljs$core$__GT_SeqIter(_seq, _next) {
  return new cljs.core.SeqIter(_seq, _next);
};
cljs.core.seq_iter = function cljs$core$seq_iter(coll) {
  return new cljs.core.SeqIter(cljs.core.INIT, coll);
};
cljs.core.iter = function cljs$core$iter(coll) {
  if (coll == null) return cljs.core.nil_iter();
  else if (typeof coll === 'string') return cljs.core.string_iter(coll);
  else if (cljs.core.array_QMARK_(coll)) return cljs.core.array_iter(coll);
  else if (cljs.core.iterable_QMARK_(coll)) return cljs.core._iterator(coll);
  else if (cljs.core.seqable_QMARK_(coll)) return cljs.core.seq_iter(coll);
  else throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          'Cannot create iterator from '
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll)
      ].join('')
    );
};
cljs.core.lazy_transformer = function cljs$core$lazy_transformer(stepper) {
  return new cljs.core.LazyTransformer(stepper, null, null, null);
};
cljs.core.Stepper = function(xform, iter) {
  this.xform = xform;
  this.iter = iter;
};
cljs.core.Stepper.prototype.step = function(lt) {
  var self__ = this;
  var this$ = this;
  while (true) {
    if (
      cljs.core.truth_(
        (function() {
          var and__7132__auto__ = !(lt.stepper == null);
          if (and__7132__auto__) return self__.iter.hasNext();
          else return and__7132__auto__;
        })()
      )
    )
      if (
        cljs.core.reduced_QMARK_(
          (function() {
            var G__10557 = lt;
            var G__10558 = self__.iter.next();
            return self__.xform.cljs$core$IFn$_invoke$arity$2
              ? self__.xform.cljs$core$IFn$_invoke$arity$2(G__10557, G__10558)
              : self__.xform.call(null, G__10557, G__10558);
          })()
        )
      )
        if (lt.rest == null);
        else lt.rest.stepper = null;
      else
        continue;
    else;
    break;
  }
  if (lt.stepper == null) return null;
  else return self__.xform.cljs$core$IFn$_invoke$arity$1
      ? self__.xform.cljs$core$IFn$_invoke$arity$1(lt)
      : self__.xform.call(null, lt);
};
cljs.core.Stepper.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'xform', 'xform', -85179481, null),
      new cljs.core.Symbol(null, 'iter', 'iter', -1346195486, null)
    ],
    null
  );
};
cljs.core.Stepper.cljs$lang$type = true;
cljs.core.Stepper.cljs$lang$ctorStr = 'cljs.core/Stepper';
cljs.core.Stepper.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Stepper');
};
cljs.core.__GT_Stepper = function cljs$core$__GT_Stepper(xform, iter) {
  return new cljs.core.Stepper(xform, iter);
};
cljs.core.stepper = function cljs$core$stepper(xform, iter) {
  var stepfn = (function() {
    var cljs$core$stepper_$_stepfn = null;
    var cljs$core$stepper_$_stepfn__1 = function(result) {
      var lt = cljs.core.reduced_QMARK_(result)
        ? cljs.core.deref(result)
        : result;
      lt.stepper = null;
      return result;
    };
    var cljs$core$stepper_$_stepfn__2 = function(result, input) {
      var lt = result;
      lt.first = input;
      lt.rest = cljs.core.lazy_transformer(lt.stepper);
      lt.stepper = null;
      return lt.rest;
    };
    cljs$core$stepper_$_stepfn = function(result, input) {
      switch (arguments.length) {
        case 1:
          return cljs$core$stepper_$_stepfn__1.call(this, result);
        case 2:
          return cljs$core$stepper_$_stepfn__2.call(this, result, input);
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$stepper_$_stepfn.cljs$core$IFn$_invoke$arity$1 = cljs$core$stepper_$_stepfn__1;
    cljs$core$stepper_$_stepfn.cljs$core$IFn$_invoke$arity$2 = cljs$core$stepper_$_stepfn__2;
    return cljs$core$stepper_$_stepfn;
  })();
  return new cljs.core.Stepper(
    xform.cljs$core$IFn$_invoke$arity$1
      ? xform.cljs$core$IFn$_invoke$arity$1(stepfn)
      : xform.call(null, stepfn),
    iter
  );
};
cljs.core.MultiStepper = function(xform, iters, nexts) {
  this.xform = xform;
  this.iters = iters;
  this.nexts = nexts;
};
cljs.core.MultiStepper.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  var iters__$1 = cljs.core.seq(self__.iters);
  while (true) {
    if (!(iters__$1 == null)) {
      var iter = cljs.core.first(iters__$1);
      if (!iter.hasNext())
        return false;
      else {
        var G__10559 = cljs.core.next(iters__$1);
        iters__$1 = G__10559;
        continue;
      }
    } else
      return true;
    break;
  }
};
cljs.core.MultiStepper.prototype.next = function() {
  var self__ = this;
  var _ = this;
  var n__8067__auto___10560 = self__.iters.length;
  var i_10561 = 0;
  while (true) {
    if (i_10561 < n__8067__auto___10560) {
      self__.nexts[i_10561] = self__.iters[i_10561].next();
      var G__10562 = i_10561 + 1;
      i_10561 = G__10562;
      continue;
    } else;
    break;
  }
  return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(self__.nexts, 0);
};
cljs.core.MultiStepper.prototype.step = function(lt) {
  var self__ = this;
  var this$ = this;
  while (true) {
    if (
      cljs.core.truth_(
        (function() {
          var and__7132__auto__ = !(lt.stepper == null);
          if (and__7132__auto__) return this$.hasNext();
          else return and__7132__auto__;
        })()
      )
    )
      if (
        cljs.core.reduced_QMARK_(
          cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
            self__.xform,
            cljs.core.cons(lt, this$.next())
          )
        )
      )
        if (lt.rest == null);
        else lt.rest.stepper = null;
      else
        continue;
    else;
    break;
  }
  if (lt.stepper == null) return null;
  else return self__.xform.cljs$core$IFn$_invoke$arity$1
      ? self__.xform.cljs$core$IFn$_invoke$arity$1(lt)
      : self__.xform.call(null, lt);
};
cljs.core.MultiStepper.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    3,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'xform', 'xform', -85179481, null),
      new cljs.core.Symbol(null, 'iters', 'iters', 719353031, null),
      new cljs.core.Symbol(null, 'nexts', 'nexts', -1683579407, null)
    ],
    null
  );
};
cljs.core.MultiStepper.cljs$lang$type = true;
cljs.core.MultiStepper.cljs$lang$ctorStr = 'cljs.core/MultiStepper';
cljs.core.MultiStepper.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/MultiStepper');
};
cljs.core.__GT_MultiStepper = function cljs$core$__GT_MultiStepper(
  xform,
  iters,
  nexts
) {
  return new cljs.core.MultiStepper(xform, iters, nexts);
};
cljs.core.multi_stepper = function cljs$core$multi_stepper(var_args) {
  var args10563 = [];
  var len__8257__auto___10566 = arguments.length;
  var i__8258__auto___10567 = 0;
  while (true) {
    if (i__8258__auto___10567 < len__8257__auto___10566) {
      args10563.push(arguments[i__8258__auto___10567]);
      var G__10568 = i__8258__auto___10567 + 1;
      i__8258__auto___10567 = G__10568;
      continue;
    } else;
    break;
  }
  var G__10565 = args10563.length;
  switch (G__10565) {
    case 2:
      return cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10563.length)
        ].join('')
      );
  }
};
cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$2 = function(xform, iters) {
  return cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$3(
    xform,
    iters,
    new Array(iters.length)
  );
};
cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$3 = function(
  xform,
  iters,
  nexts
) {
  var stepfn = (function() {
    var cljs$core$stepfn = null;
    var cljs$core$stepfn__1 = function(result) {
      var lt = cljs.core.reduced_QMARK_(result)
        ? cljs.core.deref(result)
        : result;
      lt.stepper = null;
      return lt;
    };
    var cljs$core$stepfn__2 = function(result, input) {
      var lt = result;
      lt.first = input;
      lt.rest = cljs.core.lazy_transformer(lt.stepper);
      lt.stepper = null;
      return lt.rest;
    };
    cljs$core$stepfn = function(result, input) {
      switch (arguments.length) {
        case 1:
          return cljs$core$stepfn__1.call(this, result);
        case 2:
          return cljs$core$stepfn__2.call(this, result, input);
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$stepfn.cljs$core$IFn$_invoke$arity$1 = cljs$core$stepfn__1;
    cljs$core$stepfn.cljs$core$IFn$_invoke$arity$2 = cljs$core$stepfn__2;
    return cljs$core$stepfn;
  })();
  return new cljs.core.MultiStepper(
    xform.cljs$core$IFn$_invoke$arity$1
      ? xform.cljs$core$IFn$_invoke$arity$1(stepfn)
      : xform.call(null, stepfn),
    iters,
    nexts
  );
};
cljs.core.multi_stepper.cljs$lang$maxFixedArity = 3;
cljs.core.LazyTransformer = function(stepper, first, rest, meta) {
  this.stepper = stepper;
  this.first = first;
  this.rest = rest;
  this.meta = meta;
  this.cljs$lang$protocol_mask$partition0$ = 31850700;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.LazyTransformer.prototype.indexOf = (function() {
  var G__10570 = null;
  var G__10570__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__10570__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10570 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10570__1.call(this, x);
      case 2:
        return G__10570__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10570.cljs$core$IFn$_invoke$arity$1 = G__10570__1;
  G__10570.cljs$core$IFn$_invoke$arity$2 = G__10570__2;
  return G__10570;
})();
cljs.core.LazyTransformer.prototype.lastIndexOf = (function() {
  var G__10571 = null;
  var G__10571__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__10571__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__10571 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__10571__1.call(this, x);
      case 2:
        return G__10571__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__10571.cljs$core$IFn$_invoke$arity$1 = G__10571__1;
  G__10571.cljs$core$IFn$_invoke$arity$2 = G__10571__2;
  return G__10571;
})();
cljs.core.LazyTransformer.prototype.cljs$core$IMeta$_meta$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  return self__.meta;
};
cljs.core.LazyTransformer.prototype.cljs$core$INext$_next$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  if (self__.stepper == null);
  else this$__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (self__.rest == null) return null;
  else return cljs.core._seq(self__.rest);
};
cljs.core.LazyTransformer.prototype.cljs$core$IHash$_hash$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  return cljs.core.hash_ordered_coll(this$__$1);
};
cljs.core.LazyTransformer.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  this$,
  other
) {
  var self__ = this;
  var this$__$1 = this;
  var s = this$__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (!(s == null)) return cljs.core.equiv_sequential(this$__$1, other);
  else return cljs.core.sequential_QMARK_(other) &&
      cljs.core.seq(other) == null;
};
cljs.core.LazyTransformer.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  return cljs.core.List.EMPTY;
};
cljs.core.LazyTransformer.prototype.cljs$core$ISeq$_first$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  if (self__.stepper == null);
  else this$__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (self__.rest == null) return null;
  else return self__.first;
};
cljs.core.LazyTransformer.prototype.cljs$core$ISeq$_rest$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  if (self__.stepper == null);
  else this$__$1.cljs$core$ISeqable$_seq$arity$1(null);
  if (self__.rest == null) return cljs.core.List.EMPTY;
  else return self__.rest;
};
cljs.core.LazyTransformer.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  if (self__.stepper == null);
  else self__.stepper.step(this$__$1);
  if (self__.rest == null) return null;
  else return this$__$1;
};
cljs.core.LazyTransformer.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  this$,
  new_meta
) {
  var self__ = this;
  var this$__$1 = this;
  return new cljs.core.LazyTransformer(
    self__.stepper,
    self__.first,
    self__.rest,
    new_meta
  );
};
cljs.core.LazyTransformer.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  this$,
  o
) {
  var self__ = this;
  var this$__$1 = this;
  return cljs.core.cons(o, this$__$1.cljs$core$ISeqable$_seq$arity$1(null));
};
cljs.core.LazyTransformer.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'stepper', 'stepper', 1159163296, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'first', 'first', 996428481, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'rest', 'rest', 398835108, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null)
    ],
    null
  );
};
cljs.core.LazyTransformer.cljs$lang$type = true;
cljs.core.LazyTransformer.cljs$lang$ctorStr = 'cljs.core/LazyTransformer';
cljs.core.LazyTransformer.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/LazyTransformer');
};
cljs.core.__GT_LazyTransformer = function cljs$core$__GT_LazyTransformer(
  stepper,
  first,
  rest,
  meta
) {
  return new cljs.core.LazyTransformer(stepper, first, rest, meta);
};
cljs.core.LazyTransformer.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.LazyTransformer.create = function(xform, coll) {
  return new cljs.core.LazyTransformer(
    cljs.core.stepper(xform, cljs.core.iter(coll)),
    null,
    null,
    null
  );
};
cljs.core.LazyTransformer.createMulti = function(xform, colls) {
  var iters = [];
  var seq__10572_10576 = cljs.core.seq(colls);
  var chunk__10573_10577 = null;
  var count__10574_10578 = 0;
  var i__10575_10579 = 0;
  while (true) {
    if (i__10575_10579 < count__10574_10578) {
      var coll_10580 = chunk__10573_10577.cljs$core$IIndexed$_nth$arity$2(
        null,
        i__10575_10579
      );
      iters.push(cljs.core.iter(coll_10580));
      var G__10581 = seq__10572_10576;
      var G__10582 = chunk__10573_10577;
      var G__10583 = count__10574_10578;
      var G__10584 = i__10575_10579 + 1;
      seq__10572_10576 = G__10581;
      chunk__10573_10577 = G__10582;
      count__10574_10578 = G__10583;
      i__10575_10579 = G__10584;
      continue;
    } else {
      var temp__4657__auto___10585 = cljs.core.seq(seq__10572_10576);
      if (temp__4657__auto___10585) {
        var seq__10572_10586__$1 = temp__4657__auto___10585;
        if (cljs.core.chunked_seq_QMARK_(seq__10572_10586__$1)) {
          var c__7963__auto___10587 = cljs.core.chunk_first(
            seq__10572_10586__$1
          );
          var G__10588 = cljs.core.chunk_rest(seq__10572_10586__$1);
          var G__10589 = c__7963__auto___10587;
          var G__10590 = cljs.core.count(c__7963__auto___10587);
          var G__10591 = 0;
          seq__10572_10576 = G__10588;
          chunk__10573_10577 = G__10589;
          count__10574_10578 = G__10590;
          i__10575_10579 = G__10591;
          continue;
        } else {
          var coll_10592 = cljs.core.first(seq__10572_10586__$1);
          iters.push(cljs.core.iter(coll_10592));
          var G__10593 = cljs.core.next(seq__10572_10586__$1);
          var G__10594 = null;
          var G__10595 = 0;
          var G__10596 = 0;
          seq__10572_10576 = G__10593;
          chunk__10573_10577 = G__10594;
          count__10574_10578 = G__10595;
          i__10575_10579 = G__10596;
          continue;
        }
      } else;
    }
    break;
  }
  return new cljs.core.LazyTransformer(
    cljs.core.multi_stepper.cljs$core$IFn$_invoke$arity$3(
      xform,
      iters,
      new Array(iters.length)
    ),
    null,
    null,
    null
  );
};
cljs.core.sequence = function cljs$core$sequence(var_args) {
  var args10597 = [];
  var len__8257__auto___10603 = arguments.length;
  var i__8258__auto___10604 = 0;
  while (true) {
    if (i__8258__auto___10604 < len__8257__auto___10603) {
      args10597.push(arguments[i__8258__auto___10604]);
      var G__10605 = i__8258__auto___10604 + 1;
      i__8258__auto___10604 = G__10605;
      continue;
    } else;
    break;
  }
  var G__10602 = args10597.length;
  switch (G__10602) {
    case 1:
      return cljs.core.sequence.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10597.slice(2),
        0,
        null
      );
      return cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.sequence.cljs$core$IFn$_invoke$arity$1 = function(coll) {
  if (cljs.core.seq_QMARK_(coll))
    return coll;
  else {
    var or__7144__auto__ = cljs.core.seq(coll);
    if (or__7144__auto__) return or__7144__auto__;
    else return cljs.core.List.EMPTY;
  }
};
cljs.core.sequence.cljs$core$IFn$_invoke$arity$2 = function(xform, coll) {
  return cljs.core.LazyTransformer.create(xform, coll);
};
cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic = function(
  xform,
  coll,
  colls
) {
  return cljs.core.LazyTransformer.createMulti(
    xform,
    cljs.core.to_array(cljs.core.cons(coll, colls))
  );
};
cljs.core.sequence.cljs$lang$applyTo = function(seq10598) {
  var G__10599 = cljs.core.first(seq10598);
  var seq10598__$1 = cljs.core.next(seq10598);
  var G__10600 = cljs.core.first(seq10598__$1);
  var seq10598__$2 = cljs.core.next(seq10598__$1);
  return cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic(
    G__10599,
    G__10600,
    seq10598__$2
  );
};
cljs.core.sequence.cljs$lang$maxFixedArity = 2;
cljs.core.every_QMARK_ = function cljs$core$every_QMARK_(pred, coll) {
  while (true) {
    if (cljs.core.seq(coll) == null)
      return true;
    else if (
      cljs.core.truth_(
        (function() {
          var G__10608 = cljs.core.first(coll);
          return pred.cljs$core$IFn$_invoke$arity$1
            ? pred.cljs$core$IFn$_invoke$arity$1(G__10608)
            : pred.call(null, G__10608);
        })()
      )
    ) {
      var G__10609 = pred;
      var G__10610 = cljs.core.next(coll);
      pred = G__10609;
      coll = G__10610;
      continue;
    } else
      return false;
    break;
  }
};
cljs.core.not_every_QMARK_ = function cljs$core$not_every_QMARK_(pred, coll) {
  return !cljs.core.every_QMARK_(pred, coll);
};
cljs.core.some = function cljs$core$some(pred, coll) {
  while (true) {
    if (cljs.core.seq(coll)) {
      var or__7144__auto__ = (function() {
        var G__10614 = cljs.core.first(coll);
        return pred.cljs$core$IFn$_invoke$arity$1
          ? pred.cljs$core$IFn$_invoke$arity$1(G__10614)
          : pred.call(null, G__10614);
      })();
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var G__10615 = pred;
        var G__10616 = cljs.core.next(coll);
        pred = G__10615;
        coll = G__10616;
        continue;
      }
    } else
      return null;
    break;
  }
};
cljs.core.not_any_QMARK_ = function cljs$core$not_any_QMARK_(pred, coll) {
  return cljs.core.not(cljs.core.some(pred, coll));
};
cljs.core.even_QMARK_ = function cljs$core$even_QMARK_(n) {
  if (cljs.core.integer_QMARK_(n)) return (n & 1) === 0;
  else throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          'Argument must be an integer: '
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)
      ].join('')
    );
};
cljs.core.odd_QMARK_ = function cljs$core$odd_QMARK_(n) {
  return !cljs.core.even_QMARK_(n);
};
cljs.core.complement = function cljs$core$complement(f) {
  return (function() {
    var G__10617 = null;
    var G__10617__0 = function() {
      return cljs.core.not(
        f.cljs$core$IFn$_invoke$arity$0
          ? f.cljs$core$IFn$_invoke$arity$0()
          : f.call(null)
      );
    };
    var G__10617__1 = function(x) {
      return cljs.core.not(
        f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(x)
          : f.call(null, x)
      );
    };
    var G__10617__2 = function(x, y) {
      return cljs.core.not(
        f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(x, y)
          : f.call(null, x, y)
      );
    };
    var G__10617__3 = (function() {
      var G__10618__delegate = function(x, y, zs) {
        return cljs.core.not(
          cljs.core.apply.cljs$core$IFn$_invoke$arity$4(f, x, y, zs)
        );
      };
      var G__10618 = function(x, y, var_args) {
        var zs = null;
        if (arguments.length > 2) {
          var G__10619__i = 0, G__10619__a = new Array(arguments.length - 2);
          while (G__10619__i < G__10619__a.length) {
            G__10619__a[G__10619__i] = arguments[G__10619__i + 2];
            ++G__10619__i;
          }
          zs = new cljs.core.IndexedSeq(G__10619__a, 0);
        }
        return G__10618__delegate.call(this, x, y, zs);
      };
      G__10618.cljs$lang$maxFixedArity = 2;
      G__10618.cljs$lang$applyTo = function(arglist__10620) {
        var x = cljs.core.first(arglist__10620);
        arglist__10620 = cljs.core.next(arglist__10620);
        var y = cljs.core.first(arglist__10620);
        var zs = cljs.core.rest(arglist__10620);
        return G__10618__delegate(x, y, zs);
      };
      G__10618.cljs$core$IFn$_invoke$arity$variadic = G__10618__delegate;
      return G__10618;
    })();
    G__10617 = function(x, y, var_args) {
      var zs = var_args;
      switch (arguments.length) {
        case 0:
          return G__10617__0.call(this);
        case 1:
          return G__10617__1.call(this, x);
        case 2:
          return G__10617__2.call(this, x, y);
        default:
          var G__10621 = null;
          if (arguments.length > 2) {
            var G__10622__i = 0, G__10622__a = new Array(arguments.length - 2);
            while (G__10622__i < G__10622__a.length) {
              G__10622__a[G__10622__i] = arguments[G__10622__i + 2];
              ++G__10622__i;
            }
            G__10621 = new cljs.core.IndexedSeq(G__10622__a, 0);
          }
          return G__10617__3.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            G__10621
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10617.cljs$lang$maxFixedArity = 2;
    G__10617.cljs$lang$applyTo = G__10617__3.cljs$lang$applyTo;
    G__10617.cljs$core$IFn$_invoke$arity$0 = G__10617__0;
    G__10617.cljs$core$IFn$_invoke$arity$1 = G__10617__1;
    G__10617.cljs$core$IFn$_invoke$arity$2 = G__10617__2;
    G__10617.cljs$core$IFn$_invoke$arity$variadic = G__10617__3.cljs$core$IFn$_invoke$arity$variadic;
    return G__10617;
  })();
};
cljs.core.constantly = function cljs$core$constantly(x) {
  return (function() {
    var G__10623__delegate = function(args) {
      return x;
    };
    var G__10623 = function(var_args) {
      var args = null;
      if (arguments.length > 0) {
        var G__10624__i = 0, G__10624__a = new Array(arguments.length - 0);
        while (G__10624__i < G__10624__a.length) {
          G__10624__a[G__10624__i] = arguments[G__10624__i + 0];
          ++G__10624__i;
        }
        args = new cljs.core.IndexedSeq(G__10624__a, 0);
      }
      return G__10623__delegate.call(this, args);
    };
    G__10623.cljs$lang$maxFixedArity = 0;
    G__10623.cljs$lang$applyTo = function(arglist__10625) {
      var args = cljs.core.seq(arglist__10625);
      return G__10623__delegate(args);
    };
    G__10623.cljs$core$IFn$_invoke$arity$variadic = G__10623__delegate;
    return G__10623;
  })();
};
cljs.core.comp = function cljs$core$comp(var_args) {
  var args10626 = [];
  var len__8257__auto___10648 = arguments.length;
  var i__8258__auto___10649 = 0;
  while (true) {
    if (i__8258__auto___10649 < len__8257__auto___10648) {
      args10626.push(arguments[i__8258__auto___10649]);
      var G__10650 = i__8258__auto___10649 + 1;
      i__8258__auto___10649 = G__10650;
      continue;
    } else;
    break;
  }
  var G__10632 = args10626.length;
  switch (G__10632) {
    case 0:
      return cljs.core.comp.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.comp.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.comp.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.comp.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10626.slice(3),
        0,
        null
      );
      return cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.comp.cljs$core$IFn$_invoke$arity$0 = function() {
  return cljs.core.identity;
};
cljs.core.comp.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return f;
};
cljs.core.comp.cljs$core$IFn$_invoke$arity$2 = function(f, g) {
  return (function() {
    var G__10652 = null;
    var G__10652__0 = function() {
      var G__10633 = g.cljs$core$IFn$_invoke$arity$0
        ? g.cljs$core$IFn$_invoke$arity$0()
        : g.call(null);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10633)
        : f.call(null, G__10633);
    };
    var G__10652__1 = function(x) {
      var G__10634 = g.cljs$core$IFn$_invoke$arity$1
        ? g.cljs$core$IFn$_invoke$arity$1(x)
        : g.call(null, x);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10634)
        : f.call(null, G__10634);
    };
    var G__10652__2 = function(x, y) {
      var G__10635 = g.cljs$core$IFn$_invoke$arity$2
        ? g.cljs$core$IFn$_invoke$arity$2(x, y)
        : g.call(null, x, y);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10635)
        : f.call(null, G__10635);
    };
    var G__10652__3 = function(x, y, z) {
      var G__10636 = g.cljs$core$IFn$_invoke$arity$3
        ? g.cljs$core$IFn$_invoke$arity$3(x, y, z)
        : g.call(null, x, y, z);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10636)
        : f.call(null, G__10636);
    };
    var G__10652__4 = (function() {
      var G__10653__delegate = function(x, y, z, args) {
        var G__10637 = cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
          g,
          x,
          y,
          z,
          args
        );
        return f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(G__10637)
          : f.call(null, G__10637);
      };
      var G__10653 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10654__i = 0, G__10654__a = new Array(arguments.length - 3);
          while (G__10654__i < G__10654__a.length) {
            G__10654__a[G__10654__i] = arguments[G__10654__i + 3];
            ++G__10654__i;
          }
          args = new cljs.core.IndexedSeq(G__10654__a, 0);
        }
        return G__10653__delegate.call(this, x, y, z, args);
      };
      G__10653.cljs$lang$maxFixedArity = 3;
      G__10653.cljs$lang$applyTo = function(arglist__10655) {
        var x = cljs.core.first(arglist__10655);
        arglist__10655 = cljs.core.next(arglist__10655);
        var y = cljs.core.first(arglist__10655);
        arglist__10655 = cljs.core.next(arglist__10655);
        var z = cljs.core.first(arglist__10655);
        var args = cljs.core.rest(arglist__10655);
        return G__10653__delegate(x, y, z, args);
      };
      G__10653.cljs$core$IFn$_invoke$arity$variadic = G__10653__delegate;
      return G__10653;
    })();
    G__10652 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return G__10652__0.call(this);
        case 1:
          return G__10652__1.call(this, x);
        case 2:
          return G__10652__2.call(this, x, y);
        case 3:
          return G__10652__3.call(this, x, y, z);
        default:
          var G__10656 = null;
          if (arguments.length > 3) {
            var G__10657__i = 0, G__10657__a = new Array(arguments.length - 3);
            while (G__10657__i < G__10657__a.length) {
              G__10657__a[G__10657__i] = arguments[G__10657__i + 3];
              ++G__10657__i;
            }
            G__10656 = new cljs.core.IndexedSeq(G__10657__a, 0);
          }
          return G__10652__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10656
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10652.cljs$lang$maxFixedArity = 3;
    G__10652.cljs$lang$applyTo = G__10652__4.cljs$lang$applyTo;
    G__10652.cljs$core$IFn$_invoke$arity$0 = G__10652__0;
    G__10652.cljs$core$IFn$_invoke$arity$1 = G__10652__1;
    G__10652.cljs$core$IFn$_invoke$arity$2 = G__10652__2;
    G__10652.cljs$core$IFn$_invoke$arity$3 = G__10652__3;
    G__10652.cljs$core$IFn$_invoke$arity$variadic = G__10652__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10652;
  })();
};
cljs.core.comp.cljs$core$IFn$_invoke$arity$3 = function(f, g, h) {
  return (function() {
    var G__10658 = null;
    var G__10658__0 = function() {
      var G__10638 = (function() {
        var G__10639 = h.cljs$core$IFn$_invoke$arity$0
          ? h.cljs$core$IFn$_invoke$arity$0()
          : h.call(null);
        return g.cljs$core$IFn$_invoke$arity$1
          ? g.cljs$core$IFn$_invoke$arity$1(G__10639)
          : g.call(null, G__10639);
      })();
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10638)
        : f.call(null, G__10638);
    };
    var G__10658__1 = function(x) {
      var G__10640 = (function() {
        var G__10641 = h.cljs$core$IFn$_invoke$arity$1
          ? h.cljs$core$IFn$_invoke$arity$1(x)
          : h.call(null, x);
        return g.cljs$core$IFn$_invoke$arity$1
          ? g.cljs$core$IFn$_invoke$arity$1(G__10641)
          : g.call(null, G__10641);
      })();
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10640)
        : f.call(null, G__10640);
    };
    var G__10658__2 = function(x, y) {
      var G__10642 = (function() {
        var G__10643 = h.cljs$core$IFn$_invoke$arity$2
          ? h.cljs$core$IFn$_invoke$arity$2(x, y)
          : h.call(null, x, y);
        return g.cljs$core$IFn$_invoke$arity$1
          ? g.cljs$core$IFn$_invoke$arity$1(G__10643)
          : g.call(null, G__10643);
      })();
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10642)
        : f.call(null, G__10642);
    };
    var G__10658__3 = function(x, y, z) {
      var G__10644 = (function() {
        var G__10645 = h.cljs$core$IFn$_invoke$arity$3
          ? h.cljs$core$IFn$_invoke$arity$3(x, y, z)
          : h.call(null, x, y, z);
        return g.cljs$core$IFn$_invoke$arity$1
          ? g.cljs$core$IFn$_invoke$arity$1(G__10645)
          : g.call(null, G__10645);
      })();
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10644)
        : f.call(null, G__10644);
    };
    var G__10658__4 = (function() {
      var G__10659__delegate = function(x, y, z, args) {
        var G__10646 = (function() {
          var G__10647 = cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
            h,
            x,
            y,
            z,
            args
          );
          return g.cljs$core$IFn$_invoke$arity$1
            ? g.cljs$core$IFn$_invoke$arity$1(G__10647)
            : g.call(null, G__10647);
        })();
        return f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(G__10646)
          : f.call(null, G__10646);
      };
      var G__10659 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10660__i = 0, G__10660__a = new Array(arguments.length - 3);
          while (G__10660__i < G__10660__a.length) {
            G__10660__a[G__10660__i] = arguments[G__10660__i + 3];
            ++G__10660__i;
          }
          args = new cljs.core.IndexedSeq(G__10660__a, 0);
        }
        return G__10659__delegate.call(this, x, y, z, args);
      };
      G__10659.cljs$lang$maxFixedArity = 3;
      G__10659.cljs$lang$applyTo = function(arglist__10661) {
        var x = cljs.core.first(arglist__10661);
        arglist__10661 = cljs.core.next(arglist__10661);
        var y = cljs.core.first(arglist__10661);
        arglist__10661 = cljs.core.next(arglist__10661);
        var z = cljs.core.first(arglist__10661);
        var args = cljs.core.rest(arglist__10661);
        return G__10659__delegate(x, y, z, args);
      };
      G__10659.cljs$core$IFn$_invoke$arity$variadic = G__10659__delegate;
      return G__10659;
    })();
    G__10658 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return G__10658__0.call(this);
        case 1:
          return G__10658__1.call(this, x);
        case 2:
          return G__10658__2.call(this, x, y);
        case 3:
          return G__10658__3.call(this, x, y, z);
        default:
          var G__10662 = null;
          if (arguments.length > 3) {
            var G__10663__i = 0, G__10663__a = new Array(arguments.length - 3);
            while (G__10663__i < G__10663__a.length) {
              G__10663__a[G__10663__i] = arguments[G__10663__i + 3];
              ++G__10663__i;
            }
            G__10662 = new cljs.core.IndexedSeq(G__10663__a, 0);
          }
          return G__10658__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10662
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10658.cljs$lang$maxFixedArity = 3;
    G__10658.cljs$lang$applyTo = G__10658__4.cljs$lang$applyTo;
    G__10658.cljs$core$IFn$_invoke$arity$0 = G__10658__0;
    G__10658.cljs$core$IFn$_invoke$arity$1 = G__10658__1;
    G__10658.cljs$core$IFn$_invoke$arity$2 = G__10658__2;
    G__10658.cljs$core$IFn$_invoke$arity$3 = G__10658__3;
    G__10658.cljs$core$IFn$_invoke$arity$variadic = G__10658__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10658;
  })();
};
cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic = function(f1, f2, f3, fs) {
  var fs__$1 = cljs.core.reverse(
    cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(f1, f2, f3, fs)
  );
  return (function(fs__$1) {
    return (function() {
      var G__10664__delegate = function(args) {
        var ret = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
          cljs.core.first(fs__$1),
          args
        );
        var fs__$2 = cljs.core.next(fs__$1);
        while (true) {
          if (fs__$2) {
            var G__10665 = cljs.core.first(fs__$2).call(null, ret);
            var G__10666 = cljs.core.next(fs__$2);
            ret = G__10665;
            fs__$2 = G__10666;
            continue;
          } else
            return ret;
          break;
        }
      };
      var G__10664 = function(var_args) {
        var args = null;
        if (arguments.length > 0) {
          var G__10667__i = 0, G__10667__a = new Array(arguments.length - 0);
          while (G__10667__i < G__10667__a.length) {
            G__10667__a[G__10667__i] = arguments[G__10667__i + 0];
            ++G__10667__i;
          }
          args = new cljs.core.IndexedSeq(G__10667__a, 0);
        }
        return G__10664__delegate.call(this, args);
      };
      G__10664.cljs$lang$maxFixedArity = 0;
      G__10664.cljs$lang$applyTo = function(arglist__10668) {
        var args = cljs.core.seq(arglist__10668);
        return G__10664__delegate(args);
      };
      G__10664.cljs$core$IFn$_invoke$arity$variadic = G__10664__delegate;
      return G__10664;
    })();
  })(fs__$1);
};
cljs.core.comp.cljs$lang$applyTo = function(seq10627) {
  var G__10628 = cljs.core.first(seq10627);
  var seq10627__$1 = cljs.core.next(seq10627);
  var G__10629 = cljs.core.first(seq10627__$1);
  var seq10627__$2 = cljs.core.next(seq10627__$1);
  var G__10630 = cljs.core.first(seq10627__$2);
  var seq10627__$3 = cljs.core.next(seq10627__$2);
  return cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic(
    G__10628,
    G__10629,
    G__10630,
    seq10627__$3
  );
};
cljs.core.comp.cljs$lang$maxFixedArity = 3;
cljs.core.partial = function cljs$core$partial(var_args) {
  var args10669 = [];
  var len__8257__auto___10677 = arguments.length;
  var i__8258__auto___10678 = 0;
  while (true) {
    if (i__8258__auto___10678 < len__8257__auto___10677) {
      args10669.push(arguments[i__8258__auto___10678]);
      var G__10679 = i__8258__auto___10678 + 1;
      i__8258__auto___10678 = G__10679;
      continue;
    } else;
    break;
  }
  var G__10676 = args10669.length;
  switch (G__10676) {
    case 1:
      return cljs.core.partial.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.partial.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.partial.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.partial.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10669.slice(4),
        0,
        null
      );
      return cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        argseq__8276__auto__
      );
  }
};
cljs.core.partial.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return f;
};
cljs.core.partial.cljs$core$IFn$_invoke$arity$2 = function(f, arg1) {
  return (function() {
    var G__10681 = null;
    var G__10681__0 = function() {
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(arg1)
        : f.call(null, arg1);
    };
    var G__10681__1 = function(x) {
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(arg1, x)
        : f.call(null, arg1, x);
    };
    var G__10681__2 = function(x, y) {
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(arg1, x, y)
        : f.call(null, arg1, x, y);
    };
    var G__10681__3 = function(x, y, z) {
      return f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(arg1, x, y, z)
        : f.call(null, arg1, x, y, z);
    };
    var G__10681__4 = (function() {
      var G__10682__delegate = function(x, y, z, args) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
          f,
          arg1,
          x,
          y,
          z,
          cljs.core.array_seq([args], 0)
        );
      };
      var G__10682 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10683__i = 0, G__10683__a = new Array(arguments.length - 3);
          while (G__10683__i < G__10683__a.length) {
            G__10683__a[G__10683__i] = arguments[G__10683__i + 3];
            ++G__10683__i;
          }
          args = new cljs.core.IndexedSeq(G__10683__a, 0);
        }
        return G__10682__delegate.call(this, x, y, z, args);
      };
      G__10682.cljs$lang$maxFixedArity = 3;
      G__10682.cljs$lang$applyTo = function(arglist__10684) {
        var x = cljs.core.first(arglist__10684);
        arglist__10684 = cljs.core.next(arglist__10684);
        var y = cljs.core.first(arglist__10684);
        arglist__10684 = cljs.core.next(arglist__10684);
        var z = cljs.core.first(arglist__10684);
        var args = cljs.core.rest(arglist__10684);
        return G__10682__delegate(x, y, z, args);
      };
      G__10682.cljs$core$IFn$_invoke$arity$variadic = G__10682__delegate;
      return G__10682;
    })();
    G__10681 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return G__10681__0.call(this);
        case 1:
          return G__10681__1.call(this, x);
        case 2:
          return G__10681__2.call(this, x, y);
        case 3:
          return G__10681__3.call(this, x, y, z);
        default:
          var G__10685 = null;
          if (arguments.length > 3) {
            var G__10686__i = 0, G__10686__a = new Array(arguments.length - 3);
            while (G__10686__i < G__10686__a.length) {
              G__10686__a[G__10686__i] = arguments[G__10686__i + 3];
              ++G__10686__i;
            }
            G__10685 = new cljs.core.IndexedSeq(G__10686__a, 0);
          }
          return G__10681__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10685
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10681.cljs$lang$maxFixedArity = 3;
    G__10681.cljs$lang$applyTo = G__10681__4.cljs$lang$applyTo;
    G__10681.cljs$core$IFn$_invoke$arity$0 = G__10681__0;
    G__10681.cljs$core$IFn$_invoke$arity$1 = G__10681__1;
    G__10681.cljs$core$IFn$_invoke$arity$2 = G__10681__2;
    G__10681.cljs$core$IFn$_invoke$arity$3 = G__10681__3;
    G__10681.cljs$core$IFn$_invoke$arity$variadic = G__10681__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10681;
  })();
};
cljs.core.partial.cljs$core$IFn$_invoke$arity$3 = function(f, arg1, arg2) {
  return (function() {
    var G__10687 = null;
    var G__10687__0 = function() {
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(arg1, arg2)
        : f.call(null, arg1, arg2);
    };
    var G__10687__1 = function(x) {
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(arg1, arg2, x)
        : f.call(null, arg1, arg2, x);
    };
    var G__10687__2 = function(x, y) {
      return f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(arg1, arg2, x, y)
        : f.call(null, arg1, arg2, x, y);
    };
    var G__10687__3 = function(x, y, z) {
      return f.cljs$core$IFn$_invoke$arity$5
        ? f.cljs$core$IFn$_invoke$arity$5(arg1, arg2, x, y, z)
        : f.call(null, arg1, arg2, x, y, z);
    };
    var G__10687__4 = (function() {
      var G__10688__delegate = function(x, y, z, args) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
          f,
          arg1,
          arg2,
          x,
          y,
          cljs.core.array_seq([z, args], 0)
        );
      };
      var G__10688 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10689__i = 0, G__10689__a = new Array(arguments.length - 3);
          while (G__10689__i < G__10689__a.length) {
            G__10689__a[G__10689__i] = arguments[G__10689__i + 3];
            ++G__10689__i;
          }
          args = new cljs.core.IndexedSeq(G__10689__a, 0);
        }
        return G__10688__delegate.call(this, x, y, z, args);
      };
      G__10688.cljs$lang$maxFixedArity = 3;
      G__10688.cljs$lang$applyTo = function(arglist__10690) {
        var x = cljs.core.first(arglist__10690);
        arglist__10690 = cljs.core.next(arglist__10690);
        var y = cljs.core.first(arglist__10690);
        arglist__10690 = cljs.core.next(arglist__10690);
        var z = cljs.core.first(arglist__10690);
        var args = cljs.core.rest(arglist__10690);
        return G__10688__delegate(x, y, z, args);
      };
      G__10688.cljs$core$IFn$_invoke$arity$variadic = G__10688__delegate;
      return G__10688;
    })();
    G__10687 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return G__10687__0.call(this);
        case 1:
          return G__10687__1.call(this, x);
        case 2:
          return G__10687__2.call(this, x, y);
        case 3:
          return G__10687__3.call(this, x, y, z);
        default:
          var G__10691 = null;
          if (arguments.length > 3) {
            var G__10692__i = 0, G__10692__a = new Array(arguments.length - 3);
            while (G__10692__i < G__10692__a.length) {
              G__10692__a[G__10692__i] = arguments[G__10692__i + 3];
              ++G__10692__i;
            }
            G__10691 = new cljs.core.IndexedSeq(G__10692__a, 0);
          }
          return G__10687__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10691
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10687.cljs$lang$maxFixedArity = 3;
    G__10687.cljs$lang$applyTo = G__10687__4.cljs$lang$applyTo;
    G__10687.cljs$core$IFn$_invoke$arity$0 = G__10687__0;
    G__10687.cljs$core$IFn$_invoke$arity$1 = G__10687__1;
    G__10687.cljs$core$IFn$_invoke$arity$2 = G__10687__2;
    G__10687.cljs$core$IFn$_invoke$arity$3 = G__10687__3;
    G__10687.cljs$core$IFn$_invoke$arity$variadic = G__10687__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10687;
  })();
};
cljs.core.partial.cljs$core$IFn$_invoke$arity$4 = function(
  f,
  arg1,
  arg2,
  arg3
) {
  return (function() {
    var G__10693 = null;
    var G__10693__0 = function() {
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(arg1, arg2, arg3)
        : f.call(null, arg1, arg2, arg3);
    };
    var G__10693__1 = function(x) {
      return f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(arg1, arg2, arg3, x)
        : f.call(null, arg1, arg2, arg3, x);
    };
    var G__10693__2 = function(x, y) {
      return f.cljs$core$IFn$_invoke$arity$5
        ? f.cljs$core$IFn$_invoke$arity$5(arg1, arg2, arg3, x, y)
        : f.call(null, arg1, arg2, arg3, x, y);
    };
    var G__10693__3 = function(x, y, z) {
      return f.cljs$core$IFn$_invoke$arity$6
        ? f.cljs$core$IFn$_invoke$arity$6(arg1, arg2, arg3, x, y, z)
        : f.call(null, arg1, arg2, arg3, x, y, z);
    };
    var G__10693__4 = (function() {
      var G__10694__delegate = function(x, y, z, args) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
          f,
          arg1,
          arg2,
          arg3,
          x,
          cljs.core.array_seq([y, z, args], 0)
        );
      };
      var G__10694 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10695__i = 0, G__10695__a = new Array(arguments.length - 3);
          while (G__10695__i < G__10695__a.length) {
            G__10695__a[G__10695__i] = arguments[G__10695__i + 3];
            ++G__10695__i;
          }
          args = new cljs.core.IndexedSeq(G__10695__a, 0);
        }
        return G__10694__delegate.call(this, x, y, z, args);
      };
      G__10694.cljs$lang$maxFixedArity = 3;
      G__10694.cljs$lang$applyTo = function(arglist__10696) {
        var x = cljs.core.first(arglist__10696);
        arglist__10696 = cljs.core.next(arglist__10696);
        var y = cljs.core.first(arglist__10696);
        arglist__10696 = cljs.core.next(arglist__10696);
        var z = cljs.core.first(arglist__10696);
        var args = cljs.core.rest(arglist__10696);
        return G__10694__delegate(x, y, z, args);
      };
      G__10694.cljs$core$IFn$_invoke$arity$variadic = G__10694__delegate;
      return G__10694;
    })();
    G__10693 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return G__10693__0.call(this);
        case 1:
          return G__10693__1.call(this, x);
        case 2:
          return G__10693__2.call(this, x, y);
        case 3:
          return G__10693__3.call(this, x, y, z);
        default:
          var G__10697 = null;
          if (arguments.length > 3) {
            var G__10698__i = 0, G__10698__a = new Array(arguments.length - 3);
            while (G__10698__i < G__10698__a.length) {
              G__10698__a[G__10698__i] = arguments[G__10698__i + 3];
              ++G__10698__i;
            }
            G__10697 = new cljs.core.IndexedSeq(G__10698__a, 0);
          }
          return G__10693__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10697
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10693.cljs$lang$maxFixedArity = 3;
    G__10693.cljs$lang$applyTo = G__10693__4.cljs$lang$applyTo;
    G__10693.cljs$core$IFn$_invoke$arity$0 = G__10693__0;
    G__10693.cljs$core$IFn$_invoke$arity$1 = G__10693__1;
    G__10693.cljs$core$IFn$_invoke$arity$2 = G__10693__2;
    G__10693.cljs$core$IFn$_invoke$arity$3 = G__10693__3;
    G__10693.cljs$core$IFn$_invoke$arity$variadic = G__10693__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10693;
  })();
};
cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic = function(
  f,
  arg1,
  arg2,
  arg3,
  more
) {
  return (function() {
    var G__10699__delegate = function(args) {
      return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
        f,
        arg1,
        arg2,
        arg3,
        cljs.core.concat.cljs$core$IFn$_invoke$arity$2(more, args)
      );
    };
    var G__10699 = function(var_args) {
      var args = null;
      if (arguments.length > 0) {
        var G__10700__i = 0, G__10700__a = new Array(arguments.length - 0);
        while (G__10700__i < G__10700__a.length) {
          G__10700__a[G__10700__i] = arguments[G__10700__i + 0];
          ++G__10700__i;
        }
        args = new cljs.core.IndexedSeq(G__10700__a, 0);
      }
      return G__10699__delegate.call(this, args);
    };
    G__10699.cljs$lang$maxFixedArity = 0;
    G__10699.cljs$lang$applyTo = function(arglist__10701) {
      var args = cljs.core.seq(arglist__10701);
      return G__10699__delegate(args);
    };
    G__10699.cljs$core$IFn$_invoke$arity$variadic = G__10699__delegate;
    return G__10699;
  })();
};
cljs.core.partial.cljs$lang$applyTo = function(seq10670) {
  var G__10671 = cljs.core.first(seq10670);
  var seq10670__$1 = cljs.core.next(seq10670);
  var G__10672 = cljs.core.first(seq10670__$1);
  var seq10670__$2 = cljs.core.next(seq10670__$1);
  var G__10673 = cljs.core.first(seq10670__$2);
  var seq10670__$3 = cljs.core.next(seq10670__$2);
  var G__10674 = cljs.core.first(seq10670__$3);
  var seq10670__$4 = cljs.core.next(seq10670__$3);
  return cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic(
    G__10671,
    G__10672,
    G__10673,
    G__10674,
    seq10670__$4
  );
};
cljs.core.partial.cljs$lang$maxFixedArity = 4;
cljs.core.fnil = function cljs$core$fnil(var_args) {
  var args10702 = [];
  var len__8257__auto___10721 = arguments.length;
  var i__8258__auto___10722 = 0;
  while (true) {
    if (i__8258__auto___10722 < len__8257__auto___10721) {
      args10702.push(arguments[i__8258__auto___10722]);
      var G__10723 = i__8258__auto___10722 + 1;
      i__8258__auto___10722 = G__10723;
      continue;
    } else;
    break;
  }
  var G__10704 = args10702.length;
  switch (G__10704) {
    case 2:
      return cljs.core.fnil.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.fnil.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.fnil.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10702.length)
        ].join('')
      );
  }
};
cljs.core.fnil.cljs$core$IFn$_invoke$arity$2 = function(f, x) {
  return (function() {
    var G__10725 = null;
    var G__10725__1 = function(a) {
      var G__10705 = a == null ? x : a;
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__10705)
        : f.call(null, G__10705);
    };
    var G__10725__2 = function(a, b) {
      var G__10706 = a == null ? x : a;
      var G__10707 = b;
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(G__10706, G__10707)
        : f.call(null, G__10706, G__10707);
    };
    var G__10725__3 = function(a, b, c) {
      var G__10708 = a == null ? x : a;
      var G__10709 = b;
      var G__10710 = c;
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(G__10708, G__10709, G__10710)
        : f.call(null, G__10708, G__10709, G__10710);
    };
    var G__10725__4 = (function() {
      var G__10726__delegate = function(a, b, c, ds) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
          f,
          a == null ? x : a,
          b,
          c,
          ds
        );
      };
      var G__10726 = function(a, b, c, var_args) {
        var ds = null;
        if (arguments.length > 3) {
          var G__10727__i = 0, G__10727__a = new Array(arguments.length - 3);
          while (G__10727__i < G__10727__a.length) {
            G__10727__a[G__10727__i] = arguments[G__10727__i + 3];
            ++G__10727__i;
          }
          ds = new cljs.core.IndexedSeq(G__10727__a, 0);
        }
        return G__10726__delegate.call(this, a, b, c, ds);
      };
      G__10726.cljs$lang$maxFixedArity = 3;
      G__10726.cljs$lang$applyTo = function(arglist__10728) {
        var a = cljs.core.first(arglist__10728);
        arglist__10728 = cljs.core.next(arglist__10728);
        var b = cljs.core.first(arglist__10728);
        arglist__10728 = cljs.core.next(arglist__10728);
        var c = cljs.core.first(arglist__10728);
        var ds = cljs.core.rest(arglist__10728);
        return G__10726__delegate(a, b, c, ds);
      };
      G__10726.cljs$core$IFn$_invoke$arity$variadic = G__10726__delegate;
      return G__10726;
    })();
    G__10725 = function(a, b, c, var_args) {
      var ds = var_args;
      switch (arguments.length) {
        case 1:
          return G__10725__1.call(this, a);
        case 2:
          return G__10725__2.call(this, a, b);
        case 3:
          return G__10725__3.call(this, a, b, c);
        default:
          var G__10729 = null;
          if (arguments.length > 3) {
            var G__10730__i = 0, G__10730__a = new Array(arguments.length - 3);
            while (G__10730__i < G__10730__a.length) {
              G__10730__a[G__10730__i] = arguments[G__10730__i + 3];
              ++G__10730__i;
            }
            G__10729 = new cljs.core.IndexedSeq(G__10730__a, 0);
          }
          return G__10725__4.cljs$core$IFn$_invoke$arity$variadic(
            a,
            b,
            c,
            G__10729
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10725.cljs$lang$maxFixedArity = 3;
    G__10725.cljs$lang$applyTo = G__10725__4.cljs$lang$applyTo;
    G__10725.cljs$core$IFn$_invoke$arity$1 = G__10725__1;
    G__10725.cljs$core$IFn$_invoke$arity$2 = G__10725__2;
    G__10725.cljs$core$IFn$_invoke$arity$3 = G__10725__3;
    G__10725.cljs$core$IFn$_invoke$arity$variadic = G__10725__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10725;
  })();
};
cljs.core.fnil.cljs$core$IFn$_invoke$arity$3 = function(f, x, y) {
  return (function() {
    var G__10731 = null;
    var G__10731__2 = function(a, b) {
      var G__10711 = a == null ? x : a;
      var G__10712 = b == null ? y : b;
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(G__10711, G__10712)
        : f.call(null, G__10711, G__10712);
    };
    var G__10731__3 = function(a, b, c) {
      var G__10713 = a == null ? x : a;
      var G__10714 = b == null ? y : b;
      var G__10715 = c;
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(G__10713, G__10714, G__10715)
        : f.call(null, G__10713, G__10714, G__10715);
    };
    var G__10731__4 = (function() {
      var G__10732__delegate = function(a, b, c, ds) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
          f,
          a == null ? x : a,
          b == null ? y : b,
          c,
          ds
        );
      };
      var G__10732 = function(a, b, c, var_args) {
        var ds = null;
        if (arguments.length > 3) {
          var G__10733__i = 0, G__10733__a = new Array(arguments.length - 3);
          while (G__10733__i < G__10733__a.length) {
            G__10733__a[G__10733__i] = arguments[G__10733__i + 3];
            ++G__10733__i;
          }
          ds = new cljs.core.IndexedSeq(G__10733__a, 0);
        }
        return G__10732__delegate.call(this, a, b, c, ds);
      };
      G__10732.cljs$lang$maxFixedArity = 3;
      G__10732.cljs$lang$applyTo = function(arglist__10734) {
        var a = cljs.core.first(arglist__10734);
        arglist__10734 = cljs.core.next(arglist__10734);
        var b = cljs.core.first(arglist__10734);
        arglist__10734 = cljs.core.next(arglist__10734);
        var c = cljs.core.first(arglist__10734);
        var ds = cljs.core.rest(arglist__10734);
        return G__10732__delegate(a, b, c, ds);
      };
      G__10732.cljs$core$IFn$_invoke$arity$variadic = G__10732__delegate;
      return G__10732;
    })();
    G__10731 = function(a, b, c, var_args) {
      var ds = var_args;
      switch (arguments.length) {
        case 2:
          return G__10731__2.call(this, a, b);
        case 3:
          return G__10731__3.call(this, a, b, c);
        default:
          var G__10735 = null;
          if (arguments.length > 3) {
            var G__10736__i = 0, G__10736__a = new Array(arguments.length - 3);
            while (G__10736__i < G__10736__a.length) {
              G__10736__a[G__10736__i] = arguments[G__10736__i + 3];
              ++G__10736__i;
            }
            G__10735 = new cljs.core.IndexedSeq(G__10736__a, 0);
          }
          return G__10731__4.cljs$core$IFn$_invoke$arity$variadic(
            a,
            b,
            c,
            G__10735
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10731.cljs$lang$maxFixedArity = 3;
    G__10731.cljs$lang$applyTo = G__10731__4.cljs$lang$applyTo;
    G__10731.cljs$core$IFn$_invoke$arity$2 = G__10731__2;
    G__10731.cljs$core$IFn$_invoke$arity$3 = G__10731__3;
    G__10731.cljs$core$IFn$_invoke$arity$variadic = G__10731__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10731;
  })();
};
cljs.core.fnil.cljs$core$IFn$_invoke$arity$4 = function(f, x, y, z) {
  return (function() {
    var G__10737 = null;
    var G__10737__2 = function(a, b) {
      var G__10716 = a == null ? x : a;
      var G__10717 = b == null ? y : b;
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(G__10716, G__10717)
        : f.call(null, G__10716, G__10717);
    };
    var G__10737__3 = function(a, b, c) {
      var G__10718 = a == null ? x : a;
      var G__10719 = b == null ? y : b;
      var G__10720 = c == null ? z : c;
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(G__10718, G__10719, G__10720)
        : f.call(null, G__10718, G__10719, G__10720);
    };
    var G__10737__4 = (function() {
      var G__10738__delegate = function(a, b, c, ds) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(
          f,
          a == null ? x : a,
          b == null ? y : b,
          c == null ? z : c,
          ds
        );
      };
      var G__10738 = function(a, b, c, var_args) {
        var ds = null;
        if (arguments.length > 3) {
          var G__10739__i = 0, G__10739__a = new Array(arguments.length - 3);
          while (G__10739__i < G__10739__a.length) {
            G__10739__a[G__10739__i] = arguments[G__10739__i + 3];
            ++G__10739__i;
          }
          ds = new cljs.core.IndexedSeq(G__10739__a, 0);
        }
        return G__10738__delegate.call(this, a, b, c, ds);
      };
      G__10738.cljs$lang$maxFixedArity = 3;
      G__10738.cljs$lang$applyTo = function(arglist__10740) {
        var a = cljs.core.first(arglist__10740);
        arglist__10740 = cljs.core.next(arglist__10740);
        var b = cljs.core.first(arglist__10740);
        arglist__10740 = cljs.core.next(arglist__10740);
        var c = cljs.core.first(arglist__10740);
        var ds = cljs.core.rest(arglist__10740);
        return G__10738__delegate(a, b, c, ds);
      };
      G__10738.cljs$core$IFn$_invoke$arity$variadic = G__10738__delegate;
      return G__10738;
    })();
    G__10737 = function(a, b, c, var_args) {
      var ds = var_args;
      switch (arguments.length) {
        case 2:
          return G__10737__2.call(this, a, b);
        case 3:
          return G__10737__3.call(this, a, b, c);
        default:
          var G__10741 = null;
          if (arguments.length > 3) {
            var G__10742__i = 0, G__10742__a = new Array(arguments.length - 3);
            while (G__10742__i < G__10742__a.length) {
              G__10742__a[G__10742__i] = arguments[G__10742__i + 3];
              ++G__10742__i;
            }
            G__10741 = new cljs.core.IndexedSeq(G__10742__a, 0);
          }
          return G__10737__4.cljs$core$IFn$_invoke$arity$variadic(
            a,
            b,
            c,
            G__10741
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    G__10737.cljs$lang$maxFixedArity = 3;
    G__10737.cljs$lang$applyTo = G__10737__4.cljs$lang$applyTo;
    G__10737.cljs$core$IFn$_invoke$arity$2 = G__10737__2;
    G__10737.cljs$core$IFn$_invoke$arity$3 = G__10737__3;
    G__10737.cljs$core$IFn$_invoke$arity$variadic = G__10737__4.cljs$core$IFn$_invoke$arity$variadic;
    return G__10737;
  })();
};
cljs.core.fnil.cljs$lang$maxFixedArity = 4;
cljs.core.map_indexed = function cljs$core$map_indexed(var_args) {
  var args10743 = [];
  var len__8257__auto___10774 = arguments.length;
  var i__8258__auto___10775 = 0;
  while (true) {
    if (i__8258__auto___10775 < len__8257__auto___10774) {
      args10743.push(arguments[i__8258__auto___10775]);
      var G__10776 = i__8258__auto___10775 + 1;
      i__8258__auto___10775 = G__10776;
      continue;
    } else;
    break;
  }
  var G__10745 = args10743.length;
  switch (G__10745) {
    case 1:
      return cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10743.length)
        ].join('')
      );
  }
};
cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return function(rf) {
    var i = cljs.core.volatile_BANG_.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.volatile_BANG_.cljs$core$IFn$_invoke$arity$1(-1)
      : cljs.core.volatile_BANG_.call(null, -1);
    return (function(i) {
      return (function() {
        var G__10778 = null;
        var G__10778__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__10778__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__10778__2 = function(result, input) {
          var G__10746 = result;
          var G__10747 = (function() {
            var G__10748 = cljs.core._vreset_BANG_(i, cljs.core._deref(i) + 1);
            var G__10749 = input;
            return f.cljs$core$IFn$_invoke$arity$2
              ? f.cljs$core$IFn$_invoke$arity$2(G__10748, G__10749)
              : f.call(null, G__10748, G__10749);
          })();
          return rf.cljs$core$IFn$_invoke$arity$2
            ? rf.cljs$core$IFn$_invoke$arity$2(G__10746, G__10747)
            : rf.call(null, G__10746, G__10747);
        };
        G__10778 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__10778__0.call(this);
            case 1:
              return G__10778__1.call(this, result);
            case 2:
              return G__10778__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__10778.cljs$core$IFn$_invoke$arity$0 = G__10778__0;
        G__10778.cljs$core$IFn$_invoke$arity$1 = G__10778__1;
        G__10778.cljs$core$IFn$_invoke$arity$2 = G__10778__2;
        return G__10778;
      })();
    })(i);
  };
};
cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  var mapi = function cljs$core$mapi(idx, coll__$1) {
    return new cljs.core.LazySeq(
      null,
      function() {
        var temp__4657__auto__ = cljs.core.seq(coll__$1);
        if (temp__4657__auto__) {
          var s = temp__4657__auto__;
          if (cljs.core.chunked_seq_QMARK_(s)) {
            var c = cljs.core.chunk_first(s);
            var size = cljs.core.count(c);
            var b = cljs.core.chunk_buffer(size);
            var n__8067__auto___10779 = size;
            var i_10780 = 0;
            while (true) {
              if (i_10780 < n__8067__auto___10779) {
                cljs.core.chunk_append(
                  b,
                  (function() {
                    var G__10770 = idx + i_10780;
                    var G__10771 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
                      c,
                      i_10780
                    );
                    return f.cljs$core$IFn$_invoke$arity$2
                      ? f.cljs$core$IFn$_invoke$arity$2(G__10770, G__10771)
                      : f.call(null, G__10770, G__10771);
                  })()
                );
                var G__10781 = i_10780 + 1;
                i_10780 = G__10781;
                continue;
              } else;
              break;
            }
            return cljs.core.chunk_cons(
              cljs.core.chunk(b),
              cljs$core$mapi(idx + size, cljs.core.chunk_rest(s))
            );
          } else
            return cljs.core.cons(
              (function() {
                var G__10772 = idx;
                var G__10773 = cljs.core.first(s);
                return f.cljs$core$IFn$_invoke$arity$2
                  ? f.cljs$core$IFn$_invoke$arity$2(G__10772, G__10773)
                  : f.call(null, G__10772, G__10773);
              })(),
              cljs$core$mapi(idx + 1, cljs.core.rest(s))
            );
        } else
          return null;
      },
      null,
      null
    );
  };
  return mapi(0, coll);
};
cljs.core.map_indexed.cljs$lang$maxFixedArity = 2;
cljs.core.keep = function cljs$core$keep(var_args) {
  var args10782 = [];
  var len__8257__auto___10787 = arguments.length;
  var i__8258__auto___10788 = 0;
  while (true) {
    if (i__8258__auto___10788 < len__8257__auto___10787) {
      args10782.push(arguments[i__8258__auto___10788]);
      var G__10789 = i__8258__auto___10788 + 1;
      i__8258__auto___10788 = G__10789;
      continue;
    } else;
    break;
  }
  var G__10784 = args10782.length;
  switch (G__10784) {
    case 1:
      return cljs.core.keep.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.keep.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10782.length)
        ].join('')
      );
  }
};
cljs.core.keep.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return function(rf) {
    return (function() {
      var G__10791 = null;
      var G__10791__0 = function() {
        return rf.cljs$core$IFn$_invoke$arity$0
          ? rf.cljs$core$IFn$_invoke$arity$0()
          : rf.call(null);
      };
      var G__10791__1 = function(result) {
        return rf.cljs$core$IFn$_invoke$arity$1
          ? rf.cljs$core$IFn$_invoke$arity$1(result)
          : rf.call(null, result);
      };
      var G__10791__2 = function(result, input) {
        var v = f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(input)
          : f.call(null, input);
        if (v == null) return result;
        else return rf.cljs$core$IFn$_invoke$arity$2
            ? rf.cljs$core$IFn$_invoke$arity$2(result, v)
            : rf.call(null, result, v);
      };
      G__10791 = function(result, input) {
        switch (arguments.length) {
          case 0:
            return G__10791__0.call(this);
          case 1:
            return G__10791__1.call(this, result);
          case 2:
            return G__10791__2.call(this, result, input);
        }
        throw new Error('Invalid arity: ' + arguments.length);
      };
      G__10791.cljs$core$IFn$_invoke$arity$0 = G__10791__0;
      G__10791.cljs$core$IFn$_invoke$arity$1 = G__10791__1;
      G__10791.cljs$core$IFn$_invoke$arity$2 = G__10791__2;
      return G__10791;
    })();
  };
};
cljs.core.keep.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        if (cljs.core.chunked_seq_QMARK_(s)) {
          var c = cljs.core.chunk_first(s);
          var size = cljs.core.count(c);
          var b = cljs.core.chunk_buffer(size);
          var n__8067__auto___10792 = size;
          var i_10793 = 0;
          while (true) {
            if (i_10793 < n__8067__auto___10792) {
              var x_10794 = (function() {
                var G__10785 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
                  c,
                  i_10793
                );
                return f.cljs$core$IFn$_invoke$arity$1
                  ? f.cljs$core$IFn$_invoke$arity$1(G__10785)
                  : f.call(null, G__10785);
              })();
              if (x_10794 == null);
              else cljs.core.chunk_append(b, x_10794);
              var G__10795 = i_10793 + 1;
              i_10793 = G__10795;
              continue;
            } else;
            break;
          }
          return cljs.core.chunk_cons(
            cljs.core.chunk(b),
            cljs.core.keep.cljs$core$IFn$_invoke$arity$2(
              f,
              cljs.core.chunk_rest(s)
            )
          );
        } else {
          var x = (function() {
            var G__10786 = cljs.core.first(s);
            return f.cljs$core$IFn$_invoke$arity$1
              ? f.cljs$core$IFn$_invoke$arity$1(G__10786)
              : f.call(null, G__10786);
          })();
          if (x == null)
            return cljs.core.keep.cljs$core$IFn$_invoke$arity$2(
              f,
              cljs.core.rest(s)
            );
          else
            return cljs.core.cons(
              x,
              cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f, cljs.core.rest(s))
            );
        }
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.keep.cljs$lang$maxFixedArity = 2;
cljs.core.Atom = function(state, meta, validator, watches) {
  this.state = state;
  this.meta = meta;
  this.validator = validator;
  this.watches = watches;
  this.cljs$lang$protocol_mask$partition1$ = 16386;
  this.cljs$lang$protocol_mask$partition0$ = 6455296;
};
cljs.core.Atom.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
  var self__ = this;
  var o__$1 = this;
  return o__$1 === other;
};
cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.state;
};
cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.meta;
};
cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 = function(
  this$,
  oldval,
  newval
) {
  var self__ = this;
  var this$__$1 = this;
  var seq__10796 = cljs.core.seq(self__.watches);
  var chunk__10797 = null;
  var count__10798 = 0;
  var i__10799 = 0;
  while (true) {
    if (i__10799 < count__10798) {
      var vec__10800 = chunk__10797.cljs$core$IIndexed$_nth$arity$2(
        null,
        i__10799
      );
      var key = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
        vec__10800,
        0,
        null
      );
      var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__10800, 1, null);
      f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(key, this$__$1, oldval, newval)
        : f.call(null, key, this$__$1, oldval, newval);
      var G__10806 = seq__10796;
      var G__10807 = chunk__10797;
      var G__10808 = count__10798;
      var G__10809 = i__10799 + 1;
      seq__10796 = G__10806;
      chunk__10797 = G__10807;
      count__10798 = G__10808;
      i__10799 = G__10809;
      continue;
    } else {
      var temp__4657__auto__ = cljs.core.seq(seq__10796);
      if (temp__4657__auto__) {
        var seq__10796__$1 = temp__4657__auto__;
        if (cljs.core.chunked_seq_QMARK_(seq__10796__$1)) {
          var c__7963__auto__ = cljs.core.chunk_first(seq__10796__$1);
          var G__10810 = cljs.core.chunk_rest(seq__10796__$1);
          var G__10811 = c__7963__auto__;
          var G__10812 = cljs.core.count(c__7963__auto__);
          var G__10813 = 0;
          seq__10796 = G__10810;
          chunk__10797 = G__10811;
          count__10798 = G__10812;
          i__10799 = G__10813;
          continue;
        } else {
          var vec__10803 = cljs.core.first(seq__10796__$1);
          var key = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
            vec__10803,
            0,
            null
          );
          var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(
            vec__10803,
            1,
            null
          );
          f.cljs$core$IFn$_invoke$arity$4
            ? f.cljs$core$IFn$_invoke$arity$4(key, this$__$1, oldval, newval)
            : f.call(null, key, this$__$1, oldval, newval);
          var G__10814 = cljs.core.next(seq__10796__$1);
          var G__10815 = null;
          var G__10816 = 0;
          var G__10817 = 0;
          seq__10796 = G__10814;
          chunk__10797 = G__10815;
          count__10798 = G__10816;
          i__10799 = G__10817;
          continue;
        }
      } else
        return null;
    }
    break;
  }
};
cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 = function(
  this$,
  key,
  f
) {
  var self__ = this;
  var this$__$1 = this;
  this$__$1.watches = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    self__.watches,
    key,
    f
  );
  return this$__$1;
};
cljs.core.Atom.prototype.cljs$core$IWatchable$_remove_watch$arity$2 = function(
  this$,
  key
) {
  var self__ = this;
  var this$__$1 = this;
  return (this$__$1.watches = cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(
    self__.watches,
    key
  ));
};
cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
  var self__ = this;
  var this$__$1 = this;
  return goog.getUid(this$__$1);
};
cljs.core.Atom.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'state', 'state', -348086572, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'validator', 'validator', -325659154, null),
      new cljs.core.Symbol(null, 'watches', 'watches', 1367433992, null)
    ],
    null
  );
};
cljs.core.Atom.cljs$lang$type = true;
cljs.core.Atom.cljs$lang$ctorStr = 'cljs.core/Atom';
cljs.core.Atom.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Atom');
};
cljs.core.__GT_Atom = function cljs$core$__GT_Atom(
  state,
  meta,
  validator,
  watches
) {
  return new cljs.core.Atom(state, meta, validator, watches);
};
cljs.core.atom = function cljs$core$atom(var_args) {
  var args10818 = [];
  var len__8257__auto___10826 = arguments.length;
  var i__8258__auto___10827 = 0;
  while (true) {
    if (i__8258__auto___10827 < len__8257__auto___10826) {
      args10818.push(arguments[i__8258__auto___10827]);
      var G__10828 = i__8258__auto___10827 + 1;
      i__8258__auto___10827 = G__10828;
      continue;
    } else;
    break;
  }
  var G__10822 = args10818.length;
  switch (G__10822) {
    case 1:
      return cljs.core.atom.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10818.slice(1),
        0,
        null
      );
      return cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        argseq__8276__auto__
      );
  }
};
cljs.core.atom.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return new cljs.core.Atom(x, null, null, null);
};
cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic = function(x, p__10823) {
  var map__10824 = p__10823;
  var map__10824__$1 = (!(map__10824 == null)
    ? map__10824.cljs$lang$protocol_mask$partition0$ & 64 ||
        cljs.core.PROTOCOL_SENTINEL === map__10824.cljs$core$ISeq$
        ? true
        : false
    : false)
    ? cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
        cljs.core.hash_map,
        map__10824
      )
    : map__10824;
  var meta = cljs.core.get.cljs$core$IFn$_invoke$arity$2(
    map__10824__$1,
    new cljs.core.Keyword(null, 'meta', 'meta', 1499536964)
  );
  var validator = cljs.core.get.cljs$core$IFn$_invoke$arity$2(
    map__10824__$1,
    new cljs.core.Keyword(null, 'validator', 'validator', -1966190681)
  );
  return new cljs.core.Atom(x, meta, validator, null);
};
cljs.core.atom.cljs$lang$applyTo = function(seq10819) {
  var G__10820 = cljs.core.first(seq10819);
  var seq10819__$1 = cljs.core.next(seq10819);
  return cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic(
    G__10820,
    seq10819__$1
  );
};
cljs.core.atom.cljs$lang$maxFixedArity = 1;
cljs.core.reset_BANG_ = function cljs$core$reset_BANG_(a, new_value) {
  if (a instanceof cljs.core.Atom) {
    var validate = a.validator;
    if (validate == null);
    else if (
      cljs.core.truth_(
        validate.cljs$core$IFn$_invoke$arity$1
          ? validate.cljs$core$IFn$_invoke$arity$1(new_value)
          : validate.call(null, new_value)
      )
    );
    else
      throw new Error('Validator rejected reference state');
    var old_value = a.state;
    a.state = new_value;
    if (a.watches == null);
    else cljs.core._notify_watches(a, old_value, new_value);
    return new_value;
  } else
    return cljs.core._reset_BANG_(a, new_value);
};
cljs.core.swap_BANG_ = function cljs$core$swap_BANG_(var_args) {
  var args10830 = [];
  var len__8257__auto___10844 = arguments.length;
  var i__8258__auto___10845 = 0;
  while (true) {
    if (i__8258__auto___10845 < len__8257__auto___10844) {
      args10830.push(arguments[i__8258__auto___10845]);
      var G__10846 = i__8258__auto___10845 + 1;
      i__8258__auto___10845 = G__10846;
      continue;
    } else;
    break;
  }
  var G__10837 = args10830.length;
  switch (G__10837) {
    case 2:
      return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10830.slice(4),
        0,
        null
      );
      return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        argseq__8276__auto__
      );
  }
};
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2 = function(a, f) {
  if (a instanceof cljs.core.Atom)
    return cljs.core.reset_BANG_(
      a,
      (function() {
        var G__10838 = a.state;
        return f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(G__10838)
          : f.call(null, G__10838);
      })()
    );
  else
    return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2(a, f);
};
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3 = function(a, f, x) {
  if (a instanceof cljs.core.Atom)
    return cljs.core.reset_BANG_(
      a,
      (function() {
        var G__10839 = a.state;
        var G__10840 = x;
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__10839, G__10840)
          : f.call(null, G__10839, G__10840);
      })()
    );
  else
    return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3(a, f, x);
};
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4 = function(a, f, x, y) {
  if (a instanceof cljs.core.Atom)
    return cljs.core.reset_BANG_(
      a,
      (function() {
        var G__10841 = a.state;
        var G__10842 = x;
        var G__10843 = y;
        return f.cljs$core$IFn$_invoke$arity$3
          ? f.cljs$core$IFn$_invoke$arity$3(G__10841, G__10842, G__10843)
          : f.call(null, G__10841, G__10842, G__10843);
      })()
    );
  else
    return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4(a, f, x, y);
};
cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic = function(
  a,
  f,
  x,
  y,
  more
) {
  if (a instanceof cljs.core.Atom)
    return cljs.core.reset_BANG_(
      a,
      cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f, a.state, x, y, more)
    );
  else
    return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5(
      a,
      f,
      x,
      y,
      more
    );
};
cljs.core.swap_BANG_.cljs$lang$applyTo = function(seq10831) {
  var G__10832 = cljs.core.first(seq10831);
  var seq10831__$1 = cljs.core.next(seq10831);
  var G__10833 = cljs.core.first(seq10831__$1);
  var seq10831__$2 = cljs.core.next(seq10831__$1);
  var G__10834 = cljs.core.first(seq10831__$2);
  var seq10831__$3 = cljs.core.next(seq10831__$2);
  var G__10835 = cljs.core.first(seq10831__$3);
  var seq10831__$4 = cljs.core.next(seq10831__$3);
  return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(
    G__10832,
    G__10833,
    G__10834,
    G__10835,
    seq10831__$4
  );
};
cljs.core.swap_BANG_.cljs$lang$maxFixedArity = 4;
cljs.core.compare_and_set_BANG_ = function cljs$core$compare_and_set_BANG_(
  a,
  oldval,
  newval
) {
  if (
    cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
      a.cljs$core$IDeref$_deref$arity$1(null),
      oldval
    )
  ) {
    cljs.core.reset_BANG_(a, newval);
    return true;
  } else
    return false;
};
cljs.core.set_validator_BANG_ = function cljs$core$set_validator_BANG_(
  iref,
  val
) {
  return (iref.validator = val);
};
cljs.core.get_validator = function cljs$core$get_validator(iref) {
  return iref.validator;
};
cljs.core.Volatile = function(state) {
  this.state = state;
  this.cljs$lang$protocol_mask$partition0$ = 32768;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.Volatile.prototype.cljs$core$IVolatile$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.Volatile.prototype.cljs$core$IVolatile$_vreset_BANG_$arity$2 = function(
  _,
  new_state
) {
  var self__ = this;
  var ___$1 = this;
  return (self__.state = new_state);
};
cljs.core.Volatile.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return self__.state;
};
cljs.core.Volatile.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    1,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'state', 'state', -348086572, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.Volatile.cljs$lang$type = true;
cljs.core.Volatile.cljs$lang$ctorStr = 'cljs.core/Volatile';
cljs.core.Volatile.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Volatile');
};
cljs.core.__GT_Volatile = function cljs$core$__GT_Volatile(state) {
  return new cljs.core.Volatile(state);
};
cljs.core.volatile_BANG_ = function cljs$core$volatile_BANG_(val) {
  return new cljs.core.Volatile(val);
};
cljs.core.volatile_QMARK_ = function cljs$core$volatile_QMARK_(x) {
  return x instanceof cljs.core.Volatile;
};
cljs.core.vreset_BANG_ = function cljs$core$vreset_BANG_(vol, newval) {
  return cljs.core._vreset_BANG_(vol, newval);
};
cljs.core.keep_indexed = function cljs$core$keep_indexed(var_args) {
  var args10848 = [];
  var len__8257__auto___10879 = arguments.length;
  var i__8258__auto___10880 = 0;
  while (true) {
    if (i__8258__auto___10880 < len__8257__auto___10879) {
      args10848.push(arguments[i__8258__auto___10880]);
      var G__10881 = i__8258__auto___10880 + 1;
      i__8258__auto___10880 = G__10881;
      continue;
    } else;
    break;
  }
  var G__10850 = args10848.length;
  switch (G__10850) {
    case 1:
      return cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10848.length)
        ].join('')
      );
  }
};
cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return function(rf) {
    var ia = cljs.core.volatile_BANG_(-1);
    return (function(ia) {
      return (function() {
        var G__10883 = null;
        var G__10883__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__10883__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__10883__2 = function(result, input) {
          var i = cljs.core._vreset_BANG_(ia, cljs.core._deref(ia) + 1);
          var v = f.cljs$core$IFn$_invoke$arity$2
            ? f.cljs$core$IFn$_invoke$arity$2(i, input)
            : f.call(null, i, input);
          if (v == null) return result;
          else return rf.cljs$core$IFn$_invoke$arity$2
              ? rf.cljs$core$IFn$_invoke$arity$2(result, v)
              : rf.call(null, result, v);
        };
        G__10883 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__10883__0.call(this);
            case 1:
              return G__10883__1.call(this, result);
            case 2:
              return G__10883__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__10883.cljs$core$IFn$_invoke$arity$0 = G__10883__0;
        G__10883.cljs$core$IFn$_invoke$arity$1 = G__10883__1;
        G__10883.cljs$core$IFn$_invoke$arity$2 = G__10883__2;
        return G__10883;
      })();
    })(ia);
  };
};
cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  var keepi = function cljs$core$keepi(idx, coll__$1) {
    return new cljs.core.LazySeq(
      null,
      function() {
        var temp__4657__auto__ = cljs.core.seq(coll__$1);
        if (temp__4657__auto__) {
          var s = temp__4657__auto__;
          if (cljs.core.chunked_seq_QMARK_(s)) {
            var c = cljs.core.chunk_first(s);
            var size = cljs.core.count(c);
            var b = cljs.core.chunk_buffer(size);
            var n__8067__auto___10884 = size;
            var i_10885 = 0;
            while (true) {
              if (i_10885 < n__8067__auto___10884) {
                var x_10886 = (function() {
                  var G__10875 = idx + i_10885;
                  var G__10876 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
                    c,
                    i_10885
                  );
                  return f.cljs$core$IFn$_invoke$arity$2
                    ? f.cljs$core$IFn$_invoke$arity$2(G__10875, G__10876)
                    : f.call(null, G__10875, G__10876);
                })();
                if (x_10886 == null);
                else cljs.core.chunk_append(b, x_10886);
                var G__10887 = i_10885 + 1;
                i_10885 = G__10887;
                continue;
              } else;
              break;
            }
            return cljs.core.chunk_cons(
              cljs.core.chunk(b),
              cljs$core$keepi(idx + size, cljs.core.chunk_rest(s))
            );
          } else {
            var x = (function() {
              var G__10877 = idx;
              var G__10878 = cljs.core.first(s);
              return f.cljs$core$IFn$_invoke$arity$2
                ? f.cljs$core$IFn$_invoke$arity$2(G__10877, G__10878)
                : f.call(null, G__10877, G__10878);
            })();
            if (x == null) return cljs$core$keepi(idx + 1, cljs.core.rest(s));
            else return cljs.core.cons(
                x,
                cljs$core$keepi(idx + 1, cljs.core.rest(s))
              );
          }
        } else
          return null;
      },
      null,
      null
    );
  };
  return keepi(0, coll);
};
cljs.core.keep_indexed.cljs$lang$maxFixedArity = 2;
cljs.core.every_pred = function cljs$core$every_pred(var_args) {
  var args10894 = [];
  var len__8257__auto___10901 = arguments.length;
  var i__8258__auto___10902 = 0;
  while (true) {
    if (i__8258__auto___10902 < len__8257__auto___10901) {
      args10894.push(arguments[i__8258__auto___10902]);
      var G__10903 = i__8258__auto___10902 + 1;
      i__8258__auto___10902 = G__10903;
      continue;
    } else;
    break;
  }
  var G__10900 = args10894.length;
  switch (G__10900) {
    case 1:
      return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10894.slice(3),
        0,
        null
      );
      return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1 = function(p) {
  return (function() {
    var cljs$core$ep1 = null;
    var cljs$core$ep1__0 = function() {
      return true;
    };
    var cljs$core$ep1__1 = function(x) {
      return cljs.core.boolean$(
        p.cljs$core$IFn$_invoke$arity$1
          ? p.cljs$core$IFn$_invoke$arity$1(x)
          : p.call(null, x)
      );
    };
    var cljs$core$ep1__2 = function(x, y) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p.cljs$core$IFn$_invoke$arity$1
            ? p.cljs$core$IFn$_invoke$arity$1(x)
            : p.call(null, x);
          if (cljs.core.truth_(and__7132__auto__))
            return p.cljs$core$IFn$_invoke$arity$1
              ? p.cljs$core$IFn$_invoke$arity$1(y)
              : p.call(null, y);
          else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep1__3 = function(x, y, z) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p.cljs$core$IFn$_invoke$arity$1
            ? p.cljs$core$IFn$_invoke$arity$1(x)
            : p.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p.cljs$core$IFn$_invoke$arity$1
              ? p.cljs$core$IFn$_invoke$arity$1(y)
              : p.call(null, y);
            if (cljs.core.truth_(and__7132__auto____$1))
              return p.cljs$core$IFn$_invoke$arity$1
                ? p.cljs$core$IFn$_invoke$arity$1(z)
                : p.call(null, z);
            else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep1__4 = (function() {
      var G__10905__delegate = function(x, y, z, args) {
        return cljs.core.boolean$(
          (function() {
            var and__7132__auto__ = cljs$core$ep1.cljs$core$IFn$_invoke$arity$3(
              x,
              y,
              z
            );
            if (cljs.core.truth_(and__7132__auto__))
              return cljs.core.every_QMARK_(p, args);
            else
              return and__7132__auto__;
          })()
        );
      };
      var G__10905 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10906__i = 0, G__10906__a = new Array(arguments.length - 3);
          while (G__10906__i < G__10906__a.length) {
            G__10906__a[G__10906__i] = arguments[G__10906__i + 3];
            ++G__10906__i;
          }
          args = new cljs.core.IndexedSeq(G__10906__a, 0);
        }
        return G__10905__delegate.call(this, x, y, z, args);
      };
      G__10905.cljs$lang$maxFixedArity = 3;
      G__10905.cljs$lang$applyTo = function(arglist__10907) {
        var x = cljs.core.first(arglist__10907);
        arglist__10907 = cljs.core.next(arglist__10907);
        var y = cljs.core.first(arglist__10907);
        arglist__10907 = cljs.core.next(arglist__10907);
        var z = cljs.core.first(arglist__10907);
        var args = cljs.core.rest(arglist__10907);
        return G__10905__delegate(x, y, z, args);
      };
      G__10905.cljs$core$IFn$_invoke$arity$variadic = G__10905__delegate;
      return G__10905;
    })();
    cljs$core$ep1 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$ep1__0.call(this);
        case 1:
          return cljs$core$ep1__1.call(this, x);
        case 2:
          return cljs$core$ep1__2.call(this, x, y);
        case 3:
          return cljs$core$ep1__3.call(this, x, y, z);
        default:
          var G__10908 = null;
          if (arguments.length > 3) {
            var G__10909__i = 0, G__10909__a = new Array(arguments.length - 3);
            while (G__10909__i < G__10909__a.length) {
              G__10909__a[G__10909__i] = arguments[G__10909__i + 3];
              ++G__10909__i;
            }
            G__10908 = new cljs.core.IndexedSeq(G__10909__a, 0);
          }
          return cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10908
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$ep1.cljs$lang$maxFixedArity = 3;
    cljs$core$ep1.cljs$lang$applyTo = cljs$core$ep1__4.cljs$lang$applyTo;
    cljs$core$ep1.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep1__0;
    cljs$core$ep1.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep1__1;
    cljs$core$ep1.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep1__2;
    cljs$core$ep1.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep1__3;
    cljs$core$ep1.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$ep1;
  })();
};
cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2 = function(p1, p2) {
  return (function() {
    var cljs$core$ep2 = null;
    var cljs$core$ep2__0 = function() {
      return true;
    };
    var cljs$core$ep2__1 = function(x) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__))
            return p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(x)
              : p2.call(null, x);
          else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep2__2 = function(x, y) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
              ? p1.cljs$core$IFn$_invoke$arity$1(y)
              : p1.call(null, y);
            if (cljs.core.truth_(and__7132__auto____$1)) {
              var and__7132__auto____$2 = p2.cljs$core$IFn$_invoke$arity$1
                ? p2.cljs$core$IFn$_invoke$arity$1(x)
                : p2.call(null, x);
              if (cljs.core.truth_(and__7132__auto____$2))
                return p2.cljs$core$IFn$_invoke$arity$1
                  ? p2.cljs$core$IFn$_invoke$arity$1(y)
                  : p2.call(null, y);
              else
                return and__7132__auto____$2;
            } else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep2__3 = function(x, y, z) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
              ? p1.cljs$core$IFn$_invoke$arity$1(y)
              : p1.call(null, y);
            if (cljs.core.truth_(and__7132__auto____$1)) {
              var and__7132__auto____$2 = p1.cljs$core$IFn$_invoke$arity$1
                ? p1.cljs$core$IFn$_invoke$arity$1(z)
                : p1.call(null, z);
              if (cljs.core.truth_(and__7132__auto____$2)) {
                var and__7132__auto____$3 = p2.cljs$core$IFn$_invoke$arity$1
                  ? p2.cljs$core$IFn$_invoke$arity$1(x)
                  : p2.call(null, x);
                if (cljs.core.truth_(and__7132__auto____$3)) {
                  var and__7132__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                    ? p2.cljs$core$IFn$_invoke$arity$1(y)
                    : p2.call(null, y);
                  if (cljs.core.truth_(and__7132__auto____$4))
                    return p2.cljs$core$IFn$_invoke$arity$1
                      ? p2.cljs$core$IFn$_invoke$arity$1(z)
                      : p2.call(null, z);
                  else
                    return and__7132__auto____$4;
                } else
                  return and__7132__auto____$3;
              } else
                return and__7132__auto____$2;
            } else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep2__4 = (function() {
      var G__10910__delegate = function(x, y, z, args) {
        return cljs.core.boolean$(
          (function() {
            var and__7132__auto__ = cljs$core$ep2.cljs$core$IFn$_invoke$arity$3(
              x,
              y,
              z
            );
            if (cljs.core.truth_(and__7132__auto__))
              return cljs.core.every_QMARK_(
                (function(and__7132__auto__) {
                  return function(p1__10888_SHARP_) {
                    var and__7132__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
                      ? p1.cljs$core$IFn$_invoke$arity$1(p1__10888_SHARP_)
                      : p1.call(null, p1__10888_SHARP_);
                    if (cljs.core.truth_(and__7132__auto____$1))
                      return p2.cljs$core$IFn$_invoke$arity$1
                        ? p2.cljs$core$IFn$_invoke$arity$1(p1__10888_SHARP_)
                        : p2.call(null, p1__10888_SHARP_);
                    else
                      return and__7132__auto____$1;
                  };
                })(and__7132__auto__),
                args
              );
            else
              return and__7132__auto__;
          })()
        );
      };
      var G__10910 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10911__i = 0, G__10911__a = new Array(arguments.length - 3);
          while (G__10911__i < G__10911__a.length) {
            G__10911__a[G__10911__i] = arguments[G__10911__i + 3];
            ++G__10911__i;
          }
          args = new cljs.core.IndexedSeq(G__10911__a, 0);
        }
        return G__10910__delegate.call(this, x, y, z, args);
      };
      G__10910.cljs$lang$maxFixedArity = 3;
      G__10910.cljs$lang$applyTo = function(arglist__10912) {
        var x = cljs.core.first(arglist__10912);
        arglist__10912 = cljs.core.next(arglist__10912);
        var y = cljs.core.first(arglist__10912);
        arglist__10912 = cljs.core.next(arglist__10912);
        var z = cljs.core.first(arglist__10912);
        var args = cljs.core.rest(arglist__10912);
        return G__10910__delegate(x, y, z, args);
      };
      G__10910.cljs$core$IFn$_invoke$arity$variadic = G__10910__delegate;
      return G__10910;
    })();
    cljs$core$ep2 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$ep2__0.call(this);
        case 1:
          return cljs$core$ep2__1.call(this, x);
        case 2:
          return cljs$core$ep2__2.call(this, x, y);
        case 3:
          return cljs$core$ep2__3.call(this, x, y, z);
        default:
          var G__10913 = null;
          if (arguments.length > 3) {
            var G__10914__i = 0, G__10914__a = new Array(arguments.length - 3);
            while (G__10914__i < G__10914__a.length) {
              G__10914__a[G__10914__i] = arguments[G__10914__i + 3];
              ++G__10914__i;
            }
            G__10913 = new cljs.core.IndexedSeq(G__10914__a, 0);
          }
          return cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10913
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$ep2.cljs$lang$maxFixedArity = 3;
    cljs$core$ep2.cljs$lang$applyTo = cljs$core$ep2__4.cljs$lang$applyTo;
    cljs$core$ep2.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep2__0;
    cljs$core$ep2.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep2__1;
    cljs$core$ep2.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep2__2;
    cljs$core$ep2.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep2__3;
    cljs$core$ep2.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$ep2;
  })();
};
cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3 = function(p1, p2, p3) {
  return (function() {
    var cljs$core$ep3 = null;
    var cljs$core$ep3__0 = function() {
      return true;
    };
    var cljs$core$ep3__1 = function(x) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(x)
              : p2.call(null, x);
            if (cljs.core.truth_(and__7132__auto____$1))
              return p3.cljs$core$IFn$_invoke$arity$1
                ? p3.cljs$core$IFn$_invoke$arity$1(x)
                : p3.call(null, x);
            else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep3__2 = function(x, y) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(x)
              : p2.call(null, x);
            if (cljs.core.truth_(and__7132__auto____$1)) {
              var and__7132__auto____$2 = p3.cljs$core$IFn$_invoke$arity$1
                ? p3.cljs$core$IFn$_invoke$arity$1(x)
                : p3.call(null, x);
              if (cljs.core.truth_(and__7132__auto____$2)) {
                var and__7132__auto____$3 = p1.cljs$core$IFn$_invoke$arity$1
                  ? p1.cljs$core$IFn$_invoke$arity$1(y)
                  : p1.call(null, y);
                if (cljs.core.truth_(and__7132__auto____$3)) {
                  var and__7132__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                    ? p2.cljs$core$IFn$_invoke$arity$1(y)
                    : p2.call(null, y);
                  if (cljs.core.truth_(and__7132__auto____$4))
                    return p3.cljs$core$IFn$_invoke$arity$1
                      ? p3.cljs$core$IFn$_invoke$arity$1(y)
                      : p3.call(null, y);
                  else
                    return and__7132__auto____$4;
                } else
                  return and__7132__auto____$3;
              } else
                return and__7132__auto____$2;
            } else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep3__3 = function(x, y, z) {
      return cljs.core.boolean$(
        (function() {
          var and__7132__auto__ = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(x)
            : p1.call(null, x);
          if (cljs.core.truth_(and__7132__auto__)) {
            var and__7132__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(x)
              : p2.call(null, x);
            if (cljs.core.truth_(and__7132__auto____$1)) {
              var and__7132__auto____$2 = p3.cljs$core$IFn$_invoke$arity$1
                ? p3.cljs$core$IFn$_invoke$arity$1(x)
                : p3.call(null, x);
              if (cljs.core.truth_(and__7132__auto____$2)) {
                var and__7132__auto____$3 = p1.cljs$core$IFn$_invoke$arity$1
                  ? p1.cljs$core$IFn$_invoke$arity$1(y)
                  : p1.call(null, y);
                if (cljs.core.truth_(and__7132__auto____$3)) {
                  var and__7132__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                    ? p2.cljs$core$IFn$_invoke$arity$1(y)
                    : p2.call(null, y);
                  if (cljs.core.truth_(and__7132__auto____$4)) {
                    var and__7132__auto____$5 = p3.cljs$core$IFn$_invoke$arity$1
                      ? p3.cljs$core$IFn$_invoke$arity$1(y)
                      : p3.call(null, y);
                    if (cljs.core.truth_(and__7132__auto____$5)) {
                      var and__7132__auto____$6 = p1.cljs$core$IFn$_invoke$arity$1
                        ? p1.cljs$core$IFn$_invoke$arity$1(z)
                        : p1.call(null, z);
                      if (cljs.core.truth_(and__7132__auto____$6)) {
                        var and__7132__auto____$7 = p2.cljs$core$IFn$_invoke$arity$1
                          ? p2.cljs$core$IFn$_invoke$arity$1(z)
                          : p2.call(null, z);
                        if (cljs.core.truth_(and__7132__auto____$7))
                          return p3.cljs$core$IFn$_invoke$arity$1
                            ? p3.cljs$core$IFn$_invoke$arity$1(z)
                            : p3.call(null, z);
                        else
                          return and__7132__auto____$7;
                      } else
                        return and__7132__auto____$6;
                    } else
                      return and__7132__auto____$5;
                  } else
                    return and__7132__auto____$4;
                } else
                  return and__7132__auto____$3;
              } else
                return and__7132__auto____$2;
            } else
              return and__7132__auto____$1;
          } else
            return and__7132__auto__;
        })()
      );
    };
    var cljs$core$ep3__4 = (function() {
      var G__10915__delegate = function(x, y, z, args) {
        return cljs.core.boolean$(
          (function() {
            var and__7132__auto__ = cljs$core$ep3.cljs$core$IFn$_invoke$arity$3(
              x,
              y,
              z
            );
            if (cljs.core.truth_(and__7132__auto__))
              return cljs.core.every_QMARK_(
                (function(and__7132__auto__) {
                  return function(p1__10889_SHARP_) {
                    var and__7132__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
                      ? p1.cljs$core$IFn$_invoke$arity$1(p1__10889_SHARP_)
                      : p1.call(null, p1__10889_SHARP_);
                    if (cljs.core.truth_(and__7132__auto____$1)) {
                      var and__7132__auto____$2 = p2.cljs$core$IFn$_invoke$arity$1
                        ? p2.cljs$core$IFn$_invoke$arity$1(p1__10889_SHARP_)
                        : p2.call(null, p1__10889_SHARP_);
                      if (cljs.core.truth_(and__7132__auto____$2))
                        return p3.cljs$core$IFn$_invoke$arity$1
                          ? p3.cljs$core$IFn$_invoke$arity$1(p1__10889_SHARP_)
                          : p3.call(null, p1__10889_SHARP_);
                      else
                        return and__7132__auto____$2;
                    } else
                      return and__7132__auto____$1;
                  };
                })(and__7132__auto__),
                args
              );
            else
              return and__7132__auto__;
          })()
        );
      };
      var G__10915 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10916__i = 0, G__10916__a = new Array(arguments.length - 3);
          while (G__10916__i < G__10916__a.length) {
            G__10916__a[G__10916__i] = arguments[G__10916__i + 3];
            ++G__10916__i;
          }
          args = new cljs.core.IndexedSeq(G__10916__a, 0);
        }
        return G__10915__delegate.call(this, x, y, z, args);
      };
      G__10915.cljs$lang$maxFixedArity = 3;
      G__10915.cljs$lang$applyTo = function(arglist__10917) {
        var x = cljs.core.first(arglist__10917);
        arglist__10917 = cljs.core.next(arglist__10917);
        var y = cljs.core.first(arglist__10917);
        arglist__10917 = cljs.core.next(arglist__10917);
        var z = cljs.core.first(arglist__10917);
        var args = cljs.core.rest(arglist__10917);
        return G__10915__delegate(x, y, z, args);
      };
      G__10915.cljs$core$IFn$_invoke$arity$variadic = G__10915__delegate;
      return G__10915;
    })();
    cljs$core$ep3 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$ep3__0.call(this);
        case 1:
          return cljs$core$ep3__1.call(this, x);
        case 2:
          return cljs$core$ep3__2.call(this, x, y);
        case 3:
          return cljs$core$ep3__3.call(this, x, y, z);
        default:
          var G__10918 = null;
          if (arguments.length > 3) {
            var G__10919__i = 0, G__10919__a = new Array(arguments.length - 3);
            while (G__10919__i < G__10919__a.length) {
              G__10919__a[G__10919__i] = arguments[G__10919__i + 3];
              ++G__10919__i;
            }
            G__10918 = new cljs.core.IndexedSeq(G__10919__a, 0);
          }
          return cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10918
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$ep3.cljs$lang$maxFixedArity = 3;
    cljs$core$ep3.cljs$lang$applyTo = cljs$core$ep3__4.cljs$lang$applyTo;
    cljs$core$ep3.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep3__0;
    cljs$core$ep3.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep3__1;
    cljs$core$ep3.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep3__2;
    cljs$core$ep3.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep3__3;
    cljs$core$ep3.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$ep3;
  })();
};
cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic = function(
  p1,
  p2,
  p3,
  ps
) {
  var ps__$1 = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(
    p1,
    p2,
    p3,
    ps
  );
  return (function(ps__$1) {
    return (function() {
      var cljs$core$epn = null;
      var cljs$core$epn__0 = function() {
        return true;
      };
      var cljs$core$epn__1 = function(x) {
        return cljs.core.every_QMARK_(
          (function(ps__$1) {
            return function(p1__10890_SHARP_) {
              return p1__10890_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10890_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10890_SHARP_.call(null, x);
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$epn__2 = function(x, y) {
        return cljs.core.every_QMARK_(
          (function(ps__$1) {
            return function(p1__10891_SHARP_) {
              var and__7132__auto__ = p1__10891_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10891_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10891_SHARP_.call(null, x);
              if (cljs.core.truth_(and__7132__auto__))
                return p1__10891_SHARP_.cljs$core$IFn$_invoke$arity$1
                  ? p1__10891_SHARP_.cljs$core$IFn$_invoke$arity$1(y)
                  : p1__10891_SHARP_.call(null, y);
              else
                return and__7132__auto__;
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$epn__3 = function(x, y, z) {
        return cljs.core.every_QMARK_(
          (function(ps__$1) {
            return function(p1__10892_SHARP_) {
              var and__7132__auto__ = p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10892_SHARP_.call(null, x);
              if (cljs.core.truth_(and__7132__auto__)) {
                var and__7132__auto____$1 = p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1
                  ? p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1(y)
                  : p1__10892_SHARP_.call(null, y);
                if (cljs.core.truth_(and__7132__auto____$1))
                  return p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1
                    ? p1__10892_SHARP_.cljs$core$IFn$_invoke$arity$1(z)
                    : p1__10892_SHARP_.call(null, z);
                else
                  return and__7132__auto____$1;
              } else
                return and__7132__auto__;
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$epn__4 = (function() {
        var G__10920__delegate = function(x, y, z, args) {
          return cljs.core.boolean$(
            (function() {
              var and__7132__auto__ = cljs$core$epn.cljs$core$IFn$_invoke$arity$3(
                x,
                y,
                z
              );
              if (cljs.core.truth_(and__7132__auto__))
                return cljs.core.every_QMARK_(
                  (function(and__7132__auto__, ps__$1) {
                    return function(p1__10893_SHARP_) {
                      return cljs.core.every_QMARK_(p1__10893_SHARP_, args);
                    };
                  })(and__7132__auto__, ps__$1),
                  ps__$1
                );
              else
                return and__7132__auto__;
            })()
          );
        };
        var G__10920 = function(x, y, z, var_args) {
          var args = null;
          if (arguments.length > 3) {
            var G__10921__i = 0, G__10921__a = new Array(arguments.length - 3);
            while (G__10921__i < G__10921__a.length) {
              G__10921__a[G__10921__i] = arguments[G__10921__i + 3];
              ++G__10921__i;
            }
            args = new cljs.core.IndexedSeq(G__10921__a, 0);
          }
          return G__10920__delegate.call(this, x, y, z, args);
        };
        G__10920.cljs$lang$maxFixedArity = 3;
        G__10920.cljs$lang$applyTo = function(arglist__10922) {
          var x = cljs.core.first(arglist__10922);
          arglist__10922 = cljs.core.next(arglist__10922);
          var y = cljs.core.first(arglist__10922);
          arglist__10922 = cljs.core.next(arglist__10922);
          var z = cljs.core.first(arglist__10922);
          var args = cljs.core.rest(arglist__10922);
          return G__10920__delegate(x, y, z, args);
        };
        G__10920.cljs$core$IFn$_invoke$arity$variadic = G__10920__delegate;
        return G__10920;
      })();
      cljs$core$epn = function(x, y, z, var_args) {
        var args = var_args;
        switch (arguments.length) {
          case 0:
            return cljs$core$epn__0.call(this);
          case 1:
            return cljs$core$epn__1.call(this, x);
          case 2:
            return cljs$core$epn__2.call(this, x, y);
          case 3:
            return cljs$core$epn__3.call(this, x, y, z);
          default:
            var G__10923 = null;
            if (arguments.length > 3) {
              var G__10924__i = 0,
                G__10924__a = new Array(arguments.length - 3);
              while (G__10924__i < G__10924__a.length) {
                G__10924__a[G__10924__i] = arguments[G__10924__i + 3];
                ++G__10924__i;
              }
              G__10923 = new cljs.core.IndexedSeq(G__10924__a, 0);
            }
            return cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic(
              x,
              y,
              z,
              G__10923
            );
        }
        throw new Error('Invalid arity: ' + arguments.length);
      };
      cljs$core$epn.cljs$lang$maxFixedArity = 3;
      cljs$core$epn.cljs$lang$applyTo = cljs$core$epn__4.cljs$lang$applyTo;
      cljs$core$epn.cljs$core$IFn$_invoke$arity$0 = cljs$core$epn__0;
      cljs$core$epn.cljs$core$IFn$_invoke$arity$1 = cljs$core$epn__1;
      cljs$core$epn.cljs$core$IFn$_invoke$arity$2 = cljs$core$epn__2;
      cljs$core$epn.cljs$core$IFn$_invoke$arity$3 = cljs$core$epn__3;
      cljs$core$epn.cljs$core$IFn$_invoke$arity$variadic = cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic;
      return cljs$core$epn;
    })();
  })(ps__$1);
};
cljs.core.every_pred.cljs$lang$applyTo = function(seq10895) {
  var G__10896 = cljs.core.first(seq10895);
  var seq10895__$1 = cljs.core.next(seq10895);
  var G__10897 = cljs.core.first(seq10895__$1);
  var seq10895__$2 = cljs.core.next(seq10895__$1);
  var G__10898 = cljs.core.first(seq10895__$2);
  var seq10895__$3 = cljs.core.next(seq10895__$2);
  return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic(
    G__10896,
    G__10897,
    G__10898,
    seq10895__$3
  );
};
cljs.core.every_pred.cljs$lang$maxFixedArity = 3;
cljs.core.some_fn = function cljs$core$some_fn(var_args) {
  var args10931 = [];
  var len__8257__auto___10938 = arguments.length;
  var i__8258__auto___10939 = 0;
  while (true) {
    if (i__8258__auto___10939 < len__8257__auto___10938) {
      args10931.push(arguments[i__8258__auto___10939]);
      var G__10940 = i__8258__auto___10939 + 1;
      i__8258__auto___10939 = G__10940;
      continue;
    } else;
    break;
  }
  var G__10937 = args10931.length;
  switch (G__10937) {
    case 1:
      return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10931.slice(3),
        0,
        null
      );
      return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        argseq__8276__auto__
      );
  }
};
cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1 = function(p) {
  return (function() {
    var cljs$core$sp1 = null;
    var cljs$core$sp1__0 = function() {
      return null;
    };
    var cljs$core$sp1__1 = function(x) {
      return p.cljs$core$IFn$_invoke$arity$1
        ? p.cljs$core$IFn$_invoke$arity$1(x)
        : p.call(null, x);
    };
    var cljs$core$sp1__2 = function(x, y) {
      var or__7144__auto__ = p.cljs$core$IFn$_invoke$arity$1
        ? p.cljs$core$IFn$_invoke$arity$1(x)
        : p.call(null, x);
      if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
      else return p.cljs$core$IFn$_invoke$arity$1
          ? p.cljs$core$IFn$_invoke$arity$1(y)
          : p.call(null, y);
    };
    var cljs$core$sp1__3 = function(x, y, z) {
      var or__7144__auto__ = p.cljs$core$IFn$_invoke$arity$1
        ? p.cljs$core$IFn$_invoke$arity$1(x)
        : p.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p.cljs$core$IFn$_invoke$arity$1
          ? p.cljs$core$IFn$_invoke$arity$1(y)
          : p.call(null, y);
        if (cljs.core.truth_(or__7144__auto____$1)) return or__7144__auto____$1;
        else return p.cljs$core$IFn$_invoke$arity$1
            ? p.cljs$core$IFn$_invoke$arity$1(z)
            : p.call(null, z);
      }
    };
    var cljs$core$sp1__4 = (function() {
      var G__10942__delegate = function(x, y, z, args) {
        var or__7144__auto__ = cljs$core$sp1.cljs$core$IFn$_invoke$arity$3(
          x,
          y,
          z
        );
        if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
        else return cljs.core.some(p, args);
      };
      var G__10942 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10943__i = 0, G__10943__a = new Array(arguments.length - 3);
          while (G__10943__i < G__10943__a.length) {
            G__10943__a[G__10943__i] = arguments[G__10943__i + 3];
            ++G__10943__i;
          }
          args = new cljs.core.IndexedSeq(G__10943__a, 0);
        }
        return G__10942__delegate.call(this, x, y, z, args);
      };
      G__10942.cljs$lang$maxFixedArity = 3;
      G__10942.cljs$lang$applyTo = function(arglist__10944) {
        var x = cljs.core.first(arglist__10944);
        arglist__10944 = cljs.core.next(arglist__10944);
        var y = cljs.core.first(arglist__10944);
        arglist__10944 = cljs.core.next(arglist__10944);
        var z = cljs.core.first(arglist__10944);
        var args = cljs.core.rest(arglist__10944);
        return G__10942__delegate(x, y, z, args);
      };
      G__10942.cljs$core$IFn$_invoke$arity$variadic = G__10942__delegate;
      return G__10942;
    })();
    cljs$core$sp1 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$sp1__0.call(this);
        case 1:
          return cljs$core$sp1__1.call(this, x);
        case 2:
          return cljs$core$sp1__2.call(this, x, y);
        case 3:
          return cljs$core$sp1__3.call(this, x, y, z);
        default:
          var G__10945 = null;
          if (arguments.length > 3) {
            var G__10946__i = 0, G__10946__a = new Array(arguments.length - 3);
            while (G__10946__i < G__10946__a.length) {
              G__10946__a[G__10946__i] = arguments[G__10946__i + 3];
              ++G__10946__i;
            }
            G__10945 = new cljs.core.IndexedSeq(G__10946__a, 0);
          }
          return cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10945
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$sp1.cljs$lang$maxFixedArity = 3;
    cljs$core$sp1.cljs$lang$applyTo = cljs$core$sp1__4.cljs$lang$applyTo;
    cljs$core$sp1.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp1__0;
    cljs$core$sp1.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp1__1;
    cljs$core$sp1.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp1__2;
    cljs$core$sp1.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp1__3;
    cljs$core$sp1.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$sp1;
  })();
};
cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2 = function(p1, p2) {
  return (function() {
    var cljs$core$sp2 = null;
    var cljs$core$sp2__0 = function() {
      return null;
    };
    var cljs$core$sp2__1 = function(x) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
      else return p2.cljs$core$IFn$_invoke$arity$1
          ? p2.cljs$core$IFn$_invoke$arity$1(x)
          : p2.call(null, x);
    };
    var cljs$core$sp2__2 = function(x, y) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
          ? p1.cljs$core$IFn$_invoke$arity$1(y)
          : p1.call(null, y);
        if (cljs.core.truth_(or__7144__auto____$1))
          return or__7144__auto____$1;
        else {
          var or__7144__auto____$2 = p2.cljs$core$IFn$_invoke$arity$1
            ? p2.cljs$core$IFn$_invoke$arity$1(x)
            : p2.call(null, x);
          if (cljs.core.truth_(or__7144__auto____$2))
            return or__7144__auto____$2;
          else
            return p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(y)
              : p2.call(null, y);
        }
      }
    };
    var cljs$core$sp2__3 = function(x, y, z) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
          ? p1.cljs$core$IFn$_invoke$arity$1(y)
          : p1.call(null, y);
        if (cljs.core.truth_(or__7144__auto____$1))
          return or__7144__auto____$1;
        else {
          var or__7144__auto____$2 = p1.cljs$core$IFn$_invoke$arity$1
            ? p1.cljs$core$IFn$_invoke$arity$1(z)
            : p1.call(null, z);
          if (cljs.core.truth_(or__7144__auto____$2))
            return or__7144__auto____$2;
          else {
            var or__7144__auto____$3 = p2.cljs$core$IFn$_invoke$arity$1
              ? p2.cljs$core$IFn$_invoke$arity$1(x)
              : p2.call(null, x);
            if (cljs.core.truth_(or__7144__auto____$3))
              return or__7144__auto____$3;
            else {
              var or__7144__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                ? p2.cljs$core$IFn$_invoke$arity$1(y)
                : p2.call(null, y);
              if (cljs.core.truth_(or__7144__auto____$4))
                return or__7144__auto____$4;
              else
                return p2.cljs$core$IFn$_invoke$arity$1
                  ? p2.cljs$core$IFn$_invoke$arity$1(z)
                  : p2.call(null, z);
            }
          }
        }
      }
    };
    var cljs$core$sp2__4 = (function() {
      var G__10947__delegate = function(x, y, z, args) {
        var or__7144__auto__ = cljs$core$sp2.cljs$core$IFn$_invoke$arity$3(
          x,
          y,
          z
        );
        if (cljs.core.truth_(or__7144__auto__))
          return or__7144__auto__;
        else
          return cljs.core.some(
            (function(or__7144__auto__) {
              return function(p1__10925_SHARP_) {
                var or__7144__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
                  ? p1.cljs$core$IFn$_invoke$arity$1(p1__10925_SHARP_)
                  : p1.call(null, p1__10925_SHARP_);
                if (cljs.core.truth_(or__7144__auto____$1))
                  return or__7144__auto____$1;
                else
                  return p2.cljs$core$IFn$_invoke$arity$1
                    ? p2.cljs$core$IFn$_invoke$arity$1(p1__10925_SHARP_)
                    : p2.call(null, p1__10925_SHARP_);
              };
            })(or__7144__auto__),
            args
          );
      };
      var G__10947 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10948__i = 0, G__10948__a = new Array(arguments.length - 3);
          while (G__10948__i < G__10948__a.length) {
            G__10948__a[G__10948__i] = arguments[G__10948__i + 3];
            ++G__10948__i;
          }
          args = new cljs.core.IndexedSeq(G__10948__a, 0);
        }
        return G__10947__delegate.call(this, x, y, z, args);
      };
      G__10947.cljs$lang$maxFixedArity = 3;
      G__10947.cljs$lang$applyTo = function(arglist__10949) {
        var x = cljs.core.first(arglist__10949);
        arglist__10949 = cljs.core.next(arglist__10949);
        var y = cljs.core.first(arglist__10949);
        arglist__10949 = cljs.core.next(arglist__10949);
        var z = cljs.core.first(arglist__10949);
        var args = cljs.core.rest(arglist__10949);
        return G__10947__delegate(x, y, z, args);
      };
      G__10947.cljs$core$IFn$_invoke$arity$variadic = G__10947__delegate;
      return G__10947;
    })();
    cljs$core$sp2 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$sp2__0.call(this);
        case 1:
          return cljs$core$sp2__1.call(this, x);
        case 2:
          return cljs$core$sp2__2.call(this, x, y);
        case 3:
          return cljs$core$sp2__3.call(this, x, y, z);
        default:
          var G__10950 = null;
          if (arguments.length > 3) {
            var G__10951__i = 0, G__10951__a = new Array(arguments.length - 3);
            while (G__10951__i < G__10951__a.length) {
              G__10951__a[G__10951__i] = arguments[G__10951__i + 3];
              ++G__10951__i;
            }
            G__10950 = new cljs.core.IndexedSeq(G__10951__a, 0);
          }
          return cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10950
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$sp2.cljs$lang$maxFixedArity = 3;
    cljs$core$sp2.cljs$lang$applyTo = cljs$core$sp2__4.cljs$lang$applyTo;
    cljs$core$sp2.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp2__0;
    cljs$core$sp2.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp2__1;
    cljs$core$sp2.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp2__2;
    cljs$core$sp2.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp2__3;
    cljs$core$sp2.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$sp2;
  })();
};
cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3 = function(p1, p2, p3) {
  return (function() {
    var cljs$core$sp3 = null;
    var cljs$core$sp3__0 = function() {
      return null;
    };
    var cljs$core$sp3__1 = function(x) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
          ? p2.cljs$core$IFn$_invoke$arity$1(x)
          : p2.call(null, x);
        if (cljs.core.truth_(or__7144__auto____$1)) return or__7144__auto____$1;
        else return p3.cljs$core$IFn$_invoke$arity$1
            ? p3.cljs$core$IFn$_invoke$arity$1(x)
            : p3.call(null, x);
      }
    };
    var cljs$core$sp3__2 = function(x, y) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
          ? p2.cljs$core$IFn$_invoke$arity$1(x)
          : p2.call(null, x);
        if (cljs.core.truth_(or__7144__auto____$1))
          return or__7144__auto____$1;
        else {
          var or__7144__auto____$2 = p3.cljs$core$IFn$_invoke$arity$1
            ? p3.cljs$core$IFn$_invoke$arity$1(x)
            : p3.call(null, x);
          if (cljs.core.truth_(or__7144__auto____$2))
            return or__7144__auto____$2;
          else {
            var or__7144__auto____$3 = p1.cljs$core$IFn$_invoke$arity$1
              ? p1.cljs$core$IFn$_invoke$arity$1(y)
              : p1.call(null, y);
            if (cljs.core.truth_(or__7144__auto____$3))
              return or__7144__auto____$3;
            else {
              var or__7144__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                ? p2.cljs$core$IFn$_invoke$arity$1(y)
                : p2.call(null, y);
              if (cljs.core.truth_(or__7144__auto____$4))
                return or__7144__auto____$4;
              else
                return p3.cljs$core$IFn$_invoke$arity$1
                  ? p3.cljs$core$IFn$_invoke$arity$1(y)
                  : p3.call(null, y);
            }
          }
        }
      }
    };
    var cljs$core$sp3__3 = function(x, y, z) {
      var or__7144__auto__ = p1.cljs$core$IFn$_invoke$arity$1
        ? p1.cljs$core$IFn$_invoke$arity$1(x)
        : p1.call(null, x);
      if (cljs.core.truth_(or__7144__auto__))
        return or__7144__auto__;
      else {
        var or__7144__auto____$1 = p2.cljs$core$IFn$_invoke$arity$1
          ? p2.cljs$core$IFn$_invoke$arity$1(x)
          : p2.call(null, x);
        if (cljs.core.truth_(or__7144__auto____$1))
          return or__7144__auto____$1;
        else {
          var or__7144__auto____$2 = p3.cljs$core$IFn$_invoke$arity$1
            ? p3.cljs$core$IFn$_invoke$arity$1(x)
            : p3.call(null, x);
          if (cljs.core.truth_(or__7144__auto____$2))
            return or__7144__auto____$2;
          else {
            var or__7144__auto____$3 = p1.cljs$core$IFn$_invoke$arity$1
              ? p1.cljs$core$IFn$_invoke$arity$1(y)
              : p1.call(null, y);
            if (cljs.core.truth_(or__7144__auto____$3))
              return or__7144__auto____$3;
            else {
              var or__7144__auto____$4 = p2.cljs$core$IFn$_invoke$arity$1
                ? p2.cljs$core$IFn$_invoke$arity$1(y)
                : p2.call(null, y);
              if (cljs.core.truth_(or__7144__auto____$4))
                return or__7144__auto____$4;
              else {
                var or__7144__auto____$5 = p3.cljs$core$IFn$_invoke$arity$1
                  ? p3.cljs$core$IFn$_invoke$arity$1(y)
                  : p3.call(null, y);
                if (cljs.core.truth_(or__7144__auto____$5))
                  return or__7144__auto____$5;
                else {
                  var or__7144__auto____$6 = p1.cljs$core$IFn$_invoke$arity$1
                    ? p1.cljs$core$IFn$_invoke$arity$1(z)
                    : p1.call(null, z);
                  if (cljs.core.truth_(or__7144__auto____$6))
                    return or__7144__auto____$6;
                  else {
                    var or__7144__auto____$7 = p2.cljs$core$IFn$_invoke$arity$1
                      ? p2.cljs$core$IFn$_invoke$arity$1(z)
                      : p2.call(null, z);
                    if (cljs.core.truth_(or__7144__auto____$7))
                      return or__7144__auto____$7;
                    else
                      return p3.cljs$core$IFn$_invoke$arity$1
                        ? p3.cljs$core$IFn$_invoke$arity$1(z)
                        : p3.call(null, z);
                  }
                }
              }
            }
          }
        }
      }
    };
    var cljs$core$sp3__4 = (function() {
      var G__10952__delegate = function(x, y, z, args) {
        var or__7144__auto__ = cljs$core$sp3.cljs$core$IFn$_invoke$arity$3(
          x,
          y,
          z
        );
        if (cljs.core.truth_(or__7144__auto__))
          return or__7144__auto__;
        else
          return cljs.core.some(
            (function(or__7144__auto__) {
              return function(p1__10926_SHARP_) {
                var or__7144__auto____$1 = p1.cljs$core$IFn$_invoke$arity$1
                  ? p1.cljs$core$IFn$_invoke$arity$1(p1__10926_SHARP_)
                  : p1.call(null, p1__10926_SHARP_);
                if (cljs.core.truth_(or__7144__auto____$1))
                  return or__7144__auto____$1;
                else {
                  var or__7144__auto____$2 = p2.cljs$core$IFn$_invoke$arity$1
                    ? p2.cljs$core$IFn$_invoke$arity$1(p1__10926_SHARP_)
                    : p2.call(null, p1__10926_SHARP_);
                  if (cljs.core.truth_(or__7144__auto____$2))
                    return or__7144__auto____$2;
                  else
                    return p3.cljs$core$IFn$_invoke$arity$1
                      ? p3.cljs$core$IFn$_invoke$arity$1(p1__10926_SHARP_)
                      : p3.call(null, p1__10926_SHARP_);
                }
              };
            })(or__7144__auto__),
            args
          );
      };
      var G__10952 = function(x, y, z, var_args) {
        var args = null;
        if (arguments.length > 3) {
          var G__10953__i = 0, G__10953__a = new Array(arguments.length - 3);
          while (G__10953__i < G__10953__a.length) {
            G__10953__a[G__10953__i] = arguments[G__10953__i + 3];
            ++G__10953__i;
          }
          args = new cljs.core.IndexedSeq(G__10953__a, 0);
        }
        return G__10952__delegate.call(this, x, y, z, args);
      };
      G__10952.cljs$lang$maxFixedArity = 3;
      G__10952.cljs$lang$applyTo = function(arglist__10954) {
        var x = cljs.core.first(arglist__10954);
        arglist__10954 = cljs.core.next(arglist__10954);
        var y = cljs.core.first(arglist__10954);
        arglist__10954 = cljs.core.next(arglist__10954);
        var z = cljs.core.first(arglist__10954);
        var args = cljs.core.rest(arglist__10954);
        return G__10952__delegate(x, y, z, args);
      };
      G__10952.cljs$core$IFn$_invoke$arity$variadic = G__10952__delegate;
      return G__10952;
    })();
    cljs$core$sp3 = function(x, y, z, var_args) {
      var args = var_args;
      switch (arguments.length) {
        case 0:
          return cljs$core$sp3__0.call(this);
        case 1:
          return cljs$core$sp3__1.call(this, x);
        case 2:
          return cljs$core$sp3__2.call(this, x, y);
        case 3:
          return cljs$core$sp3__3.call(this, x, y, z);
        default:
          var G__10955 = null;
          if (arguments.length > 3) {
            var G__10956__i = 0, G__10956__a = new Array(arguments.length - 3);
            while (G__10956__i < G__10956__a.length) {
              G__10956__a[G__10956__i] = arguments[G__10956__i + 3];
              ++G__10956__i;
            }
            G__10955 = new cljs.core.IndexedSeq(G__10956__a, 0);
          }
          return cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic(
            x,
            y,
            z,
            G__10955
          );
      }
      throw new Error('Invalid arity: ' + arguments.length);
    };
    cljs$core$sp3.cljs$lang$maxFixedArity = 3;
    cljs$core$sp3.cljs$lang$applyTo = cljs$core$sp3__4.cljs$lang$applyTo;
    cljs$core$sp3.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp3__0;
    cljs$core$sp3.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp3__1;
    cljs$core$sp3.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp3__2;
    cljs$core$sp3.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp3__3;
    cljs$core$sp3.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic;
    return cljs$core$sp3;
  })();
};
cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic = function(
  p1,
  p2,
  p3,
  ps
) {
  var ps__$1 = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(
    p1,
    p2,
    p3,
    ps
  );
  return (function(ps__$1) {
    return (function() {
      var cljs$core$spn = null;
      var cljs$core$spn__0 = function() {
        return null;
      };
      var cljs$core$spn__1 = function(x) {
        return cljs.core.some(
          (function(ps__$1) {
            return function(p1__10927_SHARP_) {
              return p1__10927_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10927_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10927_SHARP_.call(null, x);
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$spn__2 = function(x, y) {
        return cljs.core.some(
          (function(ps__$1) {
            return function(p1__10928_SHARP_) {
              var or__7144__auto__ = p1__10928_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10928_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10928_SHARP_.call(null, x);
              if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
              else return p1__10928_SHARP_.cljs$core$IFn$_invoke$arity$1
                  ? p1__10928_SHARP_.cljs$core$IFn$_invoke$arity$1(y)
                  : p1__10928_SHARP_.call(null, y);
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$spn__3 = function(x, y, z) {
        return cljs.core.some(
          (function(ps__$1) {
            return function(p1__10929_SHARP_) {
              var or__7144__auto__ = p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1
                ? p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1(x)
                : p1__10929_SHARP_.call(null, x);
              if (cljs.core.truth_(or__7144__auto__))
                return or__7144__auto__;
              else {
                var or__7144__auto____$1 = p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1
                  ? p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1(y)
                  : p1__10929_SHARP_.call(null, y);
                if (cljs.core.truth_(or__7144__auto____$1))
                  return or__7144__auto____$1;
                else
                  return p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1
                    ? p1__10929_SHARP_.cljs$core$IFn$_invoke$arity$1(z)
                    : p1__10929_SHARP_.call(null, z);
              }
            };
          })(ps__$1),
          ps__$1
        );
      };
      var cljs$core$spn__4 = (function() {
        var G__10957__delegate = function(x, y, z, args) {
          var or__7144__auto__ = cljs$core$spn.cljs$core$IFn$_invoke$arity$3(
            x,
            y,
            z
          );
          if (cljs.core.truth_(or__7144__auto__))
            return or__7144__auto__;
          else
            return cljs.core.some(
              (function(or__7144__auto__, ps__$1) {
                return function(p1__10930_SHARP_) {
                  return cljs.core.some(p1__10930_SHARP_, args);
                };
              })(or__7144__auto__, ps__$1),
              ps__$1
            );
        };
        var G__10957 = function(x, y, z, var_args) {
          var args = null;
          if (arguments.length > 3) {
            var G__10958__i = 0, G__10958__a = new Array(arguments.length - 3);
            while (G__10958__i < G__10958__a.length) {
              G__10958__a[G__10958__i] = arguments[G__10958__i + 3];
              ++G__10958__i;
            }
            args = new cljs.core.IndexedSeq(G__10958__a, 0);
          }
          return G__10957__delegate.call(this, x, y, z, args);
        };
        G__10957.cljs$lang$maxFixedArity = 3;
        G__10957.cljs$lang$applyTo = function(arglist__10959) {
          var x = cljs.core.first(arglist__10959);
          arglist__10959 = cljs.core.next(arglist__10959);
          var y = cljs.core.first(arglist__10959);
          arglist__10959 = cljs.core.next(arglist__10959);
          var z = cljs.core.first(arglist__10959);
          var args = cljs.core.rest(arglist__10959);
          return G__10957__delegate(x, y, z, args);
        };
        G__10957.cljs$core$IFn$_invoke$arity$variadic = G__10957__delegate;
        return G__10957;
      })();
      cljs$core$spn = function(x, y, z, var_args) {
        var args = var_args;
        switch (arguments.length) {
          case 0:
            return cljs$core$spn__0.call(this);
          case 1:
            return cljs$core$spn__1.call(this, x);
          case 2:
            return cljs$core$spn__2.call(this, x, y);
          case 3:
            return cljs$core$spn__3.call(this, x, y, z);
          default:
            var G__10960 = null;
            if (arguments.length > 3) {
              var G__10961__i = 0,
                G__10961__a = new Array(arguments.length - 3);
              while (G__10961__i < G__10961__a.length) {
                G__10961__a[G__10961__i] = arguments[G__10961__i + 3];
                ++G__10961__i;
              }
              G__10960 = new cljs.core.IndexedSeq(G__10961__a, 0);
            }
            return cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic(
              x,
              y,
              z,
              G__10960
            );
        }
        throw new Error('Invalid arity: ' + arguments.length);
      };
      cljs$core$spn.cljs$lang$maxFixedArity = 3;
      cljs$core$spn.cljs$lang$applyTo = cljs$core$spn__4.cljs$lang$applyTo;
      cljs$core$spn.cljs$core$IFn$_invoke$arity$0 = cljs$core$spn__0;
      cljs$core$spn.cljs$core$IFn$_invoke$arity$1 = cljs$core$spn__1;
      cljs$core$spn.cljs$core$IFn$_invoke$arity$2 = cljs$core$spn__2;
      cljs$core$spn.cljs$core$IFn$_invoke$arity$3 = cljs$core$spn__3;
      cljs$core$spn.cljs$core$IFn$_invoke$arity$variadic = cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic;
      return cljs$core$spn;
    })();
  })(ps__$1);
};
cljs.core.some_fn.cljs$lang$applyTo = function(seq10932) {
  var G__10933 = cljs.core.first(seq10932);
  var seq10932__$1 = cljs.core.next(seq10932);
  var G__10934 = cljs.core.first(seq10932__$1);
  var seq10932__$2 = cljs.core.next(seq10932__$1);
  var G__10935 = cljs.core.first(seq10932__$2);
  var seq10932__$3 = cljs.core.next(seq10932__$2);
  return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic(
    G__10933,
    G__10934,
    G__10935,
    seq10932__$3
  );
};
cljs.core.some_fn.cljs$lang$maxFixedArity = 3;
cljs.core.map = function cljs$core$map(var_args) {
  var args10963 = [];
  var len__8257__auto___10983 = arguments.length;
  var i__8258__auto___10984 = 0;
  while (true) {
    if (i__8258__auto___10984 < len__8257__auto___10983) {
      args10963.push(arguments[i__8258__auto___10984]);
      var G__10985 = i__8258__auto___10984 + 1;
      i__8258__auto___10984 = G__10985;
      continue;
    } else;
    break;
  }
  var G__10970 = args10963.length;
  switch (G__10970) {
    case 1:
      return cljs.core.map.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.map.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.map.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.map.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args10963.slice(4),
        0,
        null
      );
      return cljs.core.map.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        argseq__8276__auto__
      );
  }
};
cljs.core.map.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return function(rf) {
    return (function() {
      var G__10987 = null;
      var G__10987__0 = function() {
        return rf.cljs$core$IFn$_invoke$arity$0
          ? rf.cljs$core$IFn$_invoke$arity$0()
          : rf.call(null);
      };
      var G__10987__1 = function(result) {
        return rf.cljs$core$IFn$_invoke$arity$1
          ? rf.cljs$core$IFn$_invoke$arity$1(result)
          : rf.call(null, result);
      };
      var G__10987__2 = function(result, input) {
        var G__10971 = result;
        var G__10972 = f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(input)
          : f.call(null, input);
        return rf.cljs$core$IFn$_invoke$arity$2
          ? rf.cljs$core$IFn$_invoke$arity$2(G__10971, G__10972)
          : rf.call(null, G__10971, G__10972);
      };
      var G__10987__3 = (function() {
        var G__10988__delegate = function(result, input, inputs) {
          var G__10973 = result;
          var G__10974 = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(
            f,
            input,
            inputs
          );
          return rf.cljs$core$IFn$_invoke$arity$2
            ? rf.cljs$core$IFn$_invoke$arity$2(G__10973, G__10974)
            : rf.call(null, G__10973, G__10974);
        };
        var G__10988 = function(result, input, var_args) {
          var inputs = null;
          if (arguments.length > 2) {
            var G__10989__i = 0, G__10989__a = new Array(arguments.length - 2);
            while (G__10989__i < G__10989__a.length) {
              G__10989__a[G__10989__i] = arguments[G__10989__i + 2];
              ++G__10989__i;
            }
            inputs = new cljs.core.IndexedSeq(G__10989__a, 0);
          }
          return G__10988__delegate.call(this, result, input, inputs);
        };
        G__10988.cljs$lang$maxFixedArity = 2;
        G__10988.cljs$lang$applyTo = function(arglist__10990) {
          var result = cljs.core.first(arglist__10990);
          arglist__10990 = cljs.core.next(arglist__10990);
          var input = cljs.core.first(arglist__10990);
          var inputs = cljs.core.rest(arglist__10990);
          return G__10988__delegate(result, input, inputs);
        };
        G__10988.cljs$core$IFn$_invoke$arity$variadic = G__10988__delegate;
        return G__10988;
      })();
      G__10987 = function(result, input, var_args) {
        var inputs = var_args;
        switch (arguments.length) {
          case 0:
            return G__10987__0.call(this);
          case 1:
            return G__10987__1.call(this, result);
          case 2:
            return G__10987__2.call(this, result, input);
          default:
            var G__10991 = null;
            if (arguments.length > 2) {
              var G__10992__i = 0,
                G__10992__a = new Array(arguments.length - 2);
              while (G__10992__i < G__10992__a.length) {
                G__10992__a[G__10992__i] = arguments[G__10992__i + 2];
                ++G__10992__i;
              }
              G__10991 = new cljs.core.IndexedSeq(G__10992__a, 0);
            }
            return G__10987__3.cljs$core$IFn$_invoke$arity$variadic(
              result,
              input,
              G__10991
            );
        }
        throw new Error('Invalid arity: ' + arguments.length);
      };
      G__10987.cljs$lang$maxFixedArity = 2;
      G__10987.cljs$lang$applyTo = G__10987__3.cljs$lang$applyTo;
      G__10987.cljs$core$IFn$_invoke$arity$0 = G__10987__0;
      G__10987.cljs$core$IFn$_invoke$arity$1 = G__10987__1;
      G__10987.cljs$core$IFn$_invoke$arity$2 = G__10987__2;
      G__10987.cljs$core$IFn$_invoke$arity$variadic = G__10987__3.cljs$core$IFn$_invoke$arity$variadic;
      return G__10987;
    })();
  };
};
cljs.core.map.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        if (cljs.core.chunked_seq_QMARK_(s)) {
          var c = cljs.core.chunk_first(s);
          var size = cljs.core.count(c);
          var b = cljs.core.chunk_buffer(size);
          var n__8067__auto___10993 = size;
          var i_10994 = 0;
          while (true) {
            if (i_10994 < n__8067__auto___10993) {
              cljs.core.chunk_append(
                b,
                (function() {
                  var G__10975 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
                    c,
                    i_10994
                  );
                  return f.cljs$core$IFn$_invoke$arity$1
                    ? f.cljs$core$IFn$_invoke$arity$1(G__10975)
                    : f.call(null, G__10975);
                })()
              );
              var G__10995 = i_10994 + 1;
              i_10994 = G__10995;
              continue;
            } else;
            break;
          }
          return cljs.core.chunk_cons(
            cljs.core.chunk(b),
            cljs.core.map.cljs$core$IFn$_invoke$arity$2(
              f,
              cljs.core.chunk_rest(s)
            )
          );
        } else
          return cljs.core.cons(
            (function() {
              var G__10976 = cljs.core.first(s);
              return f.cljs$core$IFn$_invoke$arity$1
                ? f.cljs$core$IFn$_invoke$arity$1(G__10976)
                : f.call(null, G__10976);
            })(),
            cljs.core.map.cljs$core$IFn$_invoke$arity$2(f, cljs.core.rest(s))
          );
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.map.cljs$core$IFn$_invoke$arity$3 = function(f, c1, c2) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var s1 = cljs.core.seq(c1);
      var s2 = cljs.core.seq(c2);
      if (s1 && s2)
        return cljs.core.cons(
          (function() {
            var G__10977 = cljs.core.first(s1);
            var G__10978 = cljs.core.first(s2);
            return f.cljs$core$IFn$_invoke$arity$2
              ? f.cljs$core$IFn$_invoke$arity$2(G__10977, G__10978)
              : f.call(null, G__10977, G__10978);
          })(),
          cljs.core.map.cljs$core$IFn$_invoke$arity$3(
            f,
            cljs.core.rest(s1),
            cljs.core.rest(s2)
          )
        );
      else
        return null;
    },
    null,
    null
  );
};
cljs.core.map.cljs$core$IFn$_invoke$arity$4 = function(f, c1, c2, c3) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var s1 = cljs.core.seq(c1);
      var s2 = cljs.core.seq(c2);
      var s3 = cljs.core.seq(c3);
      if (s1 && s2 && s3)
        return cljs.core.cons(
          (function() {
            var G__10979 = cljs.core.first(s1);
            var G__10980 = cljs.core.first(s2);
            var G__10981 = cljs.core.first(s3);
            return f.cljs$core$IFn$_invoke$arity$3
              ? f.cljs$core$IFn$_invoke$arity$3(G__10979, G__10980, G__10981)
              : f.call(null, G__10979, G__10980, G__10981);
          })(),
          cljs.core.map.cljs$core$IFn$_invoke$arity$4(
            f,
            cljs.core.rest(s1),
            cljs.core.rest(s2),
            cljs.core.rest(s3)
          )
        );
      else
        return null;
    },
    null,
    null
  );
};
cljs.core.map.cljs$core$IFn$_invoke$arity$variadic = function(
  f,
  c1,
  c2,
  c3,
  colls
) {
  var step = function cljs$core$step(cs) {
    return new cljs.core.LazySeq(
      null,
      function() {
        var ss = cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.seq, cs);
        if (cljs.core.every_QMARK_(cljs.core.identity, ss))
          return cljs.core.cons(
            cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first, ss),
            cljs$core$step(
              cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.rest, ss)
            )
          );
        else
          return null;
      },
      null,
      null
    );
  };
  return cljs.core.map.cljs$core$IFn$_invoke$arity$2(
    (function(step) {
      return function(p1__10962_SHARP_) {
        return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
          f,
          p1__10962_SHARP_
        );
      };
    })(step),
    step(
      cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(
        colls,
        c3,
        cljs.core.array_seq([c2, c1], 0)
      )
    )
  );
};
cljs.core.map.cljs$lang$applyTo = function(seq10964) {
  var G__10965 = cljs.core.first(seq10964);
  var seq10964__$1 = cljs.core.next(seq10964);
  var G__10966 = cljs.core.first(seq10964__$1);
  var seq10964__$2 = cljs.core.next(seq10964__$1);
  var G__10967 = cljs.core.first(seq10964__$2);
  var seq10964__$3 = cljs.core.next(seq10964__$2);
  var G__10968 = cljs.core.first(seq10964__$3);
  var seq10964__$4 = cljs.core.next(seq10964__$3);
  return cljs.core.map.cljs$core$IFn$_invoke$arity$variadic(
    G__10965,
    G__10966,
    G__10967,
    G__10968,
    seq10964__$4
  );
};
cljs.core.map.cljs$lang$maxFixedArity = 4;
cljs.core.take = function cljs$core$take(var_args) {
  var args10996 = [];
  var len__8257__auto___10999 = arguments.length;
  var i__8258__auto___11000 = 0;
  while (true) {
    if (i__8258__auto___11000 < len__8257__auto___10999) {
      args10996.push(arguments[i__8258__auto___11000]);
      var G__11001 = i__8258__auto___11000 + 1;
      i__8258__auto___11000 = G__11001;
      continue;
    } else;
    break;
  }
  var G__10998 = args10996.length;
  switch (G__10998) {
    case 1:
      return cljs.core.take.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.take.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args10996.length)
        ].join('')
      );
  }
};
cljs.core.take.cljs$core$IFn$_invoke$arity$1 = function(n) {
  if (typeof n === 'number');
  else throw new Error('Assert failed: (number? n)');
  return function(rf) {
    var na = cljs.core.volatile_BANG_(n);
    return (function(na) {
      return (function() {
        var G__11003 = null;
        var G__11003__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__11003__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__11003__2 = function(result, input) {
          var n__$1 = cljs.core.deref(na);
          var nn = cljs.core._vreset_BANG_(na, cljs.core._deref(na) - 1);
          var result__$1 = n__$1 > 0
            ? rf.cljs$core$IFn$_invoke$arity$2
                ? rf.cljs$core$IFn$_invoke$arity$2(result, input)
                : rf.call(null, result, input)
            : result;
          if (!(nn > 0)) return cljs.core.ensure_reduced(result__$1);
          else return result__$1;
        };
        G__11003 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__11003__0.call(this);
            case 1:
              return G__11003__1.call(this, result);
            case 2:
              return G__11003__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__11003.cljs$core$IFn$_invoke$arity$0 = G__11003__0;
        G__11003.cljs$core$IFn$_invoke$arity$1 = G__11003__1;
        G__11003.cljs$core$IFn$_invoke$arity$2 = G__11003__2;
        return G__11003;
      })();
    })(na);
  };
};
cljs.core.take.cljs$core$IFn$_invoke$arity$2 = function(n, coll) {
  if (typeof n === 'number');
  else throw new Error('Assert failed: (number? n)');
  return new cljs.core.LazySeq(
    null,
    function() {
      if (n > 0) {
        var temp__4657__auto__ = cljs.core.seq(coll);
        if (temp__4657__auto__) {
          var s = temp__4657__auto__;
          return cljs.core.cons(
            cljs.core.first(s),
            cljs.core.take.cljs$core$IFn$_invoke$arity$2(
              n - 1,
              cljs.core.rest(s)
            )
          );
        } else
          return null;
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.take.cljs$lang$maxFixedArity = 2;
cljs.core.drop = function cljs$core$drop(var_args) {
  var args11004 = [];
  var len__8257__auto___11007 = arguments.length;
  var i__8258__auto___11008 = 0;
  while (true) {
    if (i__8258__auto___11008 < len__8257__auto___11007) {
      args11004.push(arguments[i__8258__auto___11008]);
      var G__11009 = i__8258__auto___11008 + 1;
      i__8258__auto___11008 = G__11009;
      continue;
    } else;
    break;
  }
  var G__11006 = args11004.length;
  switch (G__11006) {
    case 1:
      return cljs.core.drop.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.drop.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11004.length)
        ].join('')
      );
  }
};
cljs.core.drop.cljs$core$IFn$_invoke$arity$1 = function(n) {
  if (typeof n === 'number');
  else throw new Error('Assert failed: (number? n)');
  return function(rf) {
    var na = cljs.core.volatile_BANG_(n);
    return (function(na) {
      return (function() {
        var G__11011 = null;
        var G__11011__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__11011__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__11011__2 = function(result, input) {
          var n__$1 = cljs.core.deref(na);
          cljs.core._vreset_BANG_(na, cljs.core._deref(na) - 1);
          if (n__$1 > 0) return result;
          else return rf.cljs$core$IFn$_invoke$arity$2
              ? rf.cljs$core$IFn$_invoke$arity$2(result, input)
              : rf.call(null, result, input);
        };
        G__11011 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__11011__0.call(this);
            case 1:
              return G__11011__1.call(this, result);
            case 2:
              return G__11011__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__11011.cljs$core$IFn$_invoke$arity$0 = G__11011__0;
        G__11011.cljs$core$IFn$_invoke$arity$1 = G__11011__1;
        G__11011.cljs$core$IFn$_invoke$arity$2 = G__11011__2;
        return G__11011;
      })();
    })(na);
  };
};
cljs.core.drop.cljs$core$IFn$_invoke$arity$2 = function(n, coll) {
  if (typeof n === 'number');
  else throw new Error('Assert failed: (number? n)');
  var step = function(n__$1, coll__$1) {
    while (true) {
      var s = cljs.core.seq(coll__$1);
      if (n__$1 > 0 && s) {
        var G__11012 = n__$1 - 1;
        var G__11013 = cljs.core.rest(s);
        n__$1 = G__11012;
        coll__$1 = G__11013;
        continue;
      } else
        return s;
      break;
    }
  };
  return new cljs.core.LazySeq(
    null,
    (function(step) {
      return function() {
        return step(n, coll);
      };
    })(step),
    null,
    null
  );
};
cljs.core.drop.cljs$lang$maxFixedArity = 2;
cljs.core.drop_last = function cljs$core$drop_last(var_args) {
  var args11014 = [];
  var len__8257__auto___11017 = arguments.length;
  var i__8258__auto___11018 = 0;
  while (true) {
    if (i__8258__auto___11018 < len__8257__auto___11017) {
      args11014.push(arguments[i__8258__auto___11018]);
      var G__11019 = i__8258__auto___11018 + 1;
      i__8258__auto___11018 = G__11019;
      continue;
    } else;
    break;
  }
  var G__11016 = args11014.length;
  switch (G__11016) {
    case 1:
      return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11014.length)
        ].join('')
      );
  }
};
cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1 = function(s) {
  return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2(1, s);
};
cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2 = function(n, s) {
  return cljs.core.map.cljs$core$IFn$_invoke$arity$3(
    function(x, _) {
      return x;
    },
    s,
    cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n, s)
  );
};
cljs.core.drop_last.cljs$lang$maxFixedArity = 2;
cljs.core.take_last = function cljs$core$take_last(n, coll) {
  var s = cljs.core.seq(coll);
  var lead = cljs.core.seq(
    cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n, coll)
  );
  while (true) {
    if (lead) {
      var G__11021 = cljs.core.next(s);
      var G__11022 = cljs.core.next(lead);
      s = G__11021;
      lead = G__11022;
      continue;
    } else
      return s;
    break;
  }
};
cljs.core.drop_while = function cljs$core$drop_while(var_args) {
  var args11023 = [];
  var len__8257__auto___11028 = arguments.length;
  var i__8258__auto___11029 = 0;
  while (true) {
    if (i__8258__auto___11029 < len__8257__auto___11028) {
      args11023.push(arguments[i__8258__auto___11029]);
      var G__11030 = i__8258__auto___11029 + 1;
      i__8258__auto___11029 = G__11030;
      continue;
    } else;
    break;
  }
  var G__11025 = args11023.length;
  switch (G__11025) {
    case 1:
      return cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11023.length)
        ].join('')
      );
  }
};
cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1 = function(pred) {
  return function(rf) {
    var da = cljs.core.volatile_BANG_(true);
    return (function(da) {
      return (function() {
        var G__11032 = null;
        var G__11032__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__11032__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__11032__2 = function(result, input) {
          var drop_QMARK_ = cljs.core.deref(da);
          if (
            cljs.core.truth_(
              (function() {
                var and__7132__auto__ = drop_QMARK_;
                if (cljs.core.truth_(and__7132__auto__))
                  return pred.cljs$core$IFn$_invoke$arity$1
                    ? pred.cljs$core$IFn$_invoke$arity$1(input)
                    : pred.call(null, input);
                else
                  return and__7132__auto__;
              })()
            )
          )
            return result;
          else {
            cljs.core.vreset_BANG_(da, null);
            return rf.cljs$core$IFn$_invoke$arity$2
              ? rf.cljs$core$IFn$_invoke$arity$2(result, input)
              : rf.call(null, result, input);
          }
        };
        G__11032 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__11032__0.call(this);
            case 1:
              return G__11032__1.call(this, result);
            case 2:
              return G__11032__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__11032.cljs$core$IFn$_invoke$arity$0 = G__11032__0;
        G__11032.cljs$core$IFn$_invoke$arity$1 = G__11032__1;
        G__11032.cljs$core$IFn$_invoke$arity$2 = G__11032__2;
        return G__11032;
      })();
    })(da);
  };
};
cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2 = function(pred, coll) {
  var step = function(pred__$1, coll__$1) {
    while (true) {
      var s = cljs.core.seq(coll__$1);
      if (
        cljs.core.truth_(
          (function() {
            var and__7132__auto__ = s;
            if (and__7132__auto__) {
              var G__11027 = cljs.core.first(s);
              return pred__$1.cljs$core$IFn$_invoke$arity$1
                ? pred__$1.cljs$core$IFn$_invoke$arity$1(G__11027)
                : pred__$1.call(null, G__11027);
            } else
              return and__7132__auto__;
          })()
        )
      ) {
        var G__11033 = pred__$1;
        var G__11034 = cljs.core.rest(s);
        pred__$1 = G__11033;
        coll__$1 = G__11034;
        continue;
      } else
        return s;
      break;
    }
  };
  return new cljs.core.LazySeq(
    null,
    (function(step) {
      return function() {
        return step(pred, coll);
      };
    })(step),
    null,
    null
  );
};
cljs.core.drop_while.cljs$lang$maxFixedArity = 2;
cljs.core.cycle = function cljs$core$cycle(coll) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(
          s,
          cljs.core.cycle.cljs$core$IFn$_invoke$arity$1
            ? cljs.core.cycle.cljs$core$IFn$_invoke$arity$1(s)
            : cljs.core.cycle.call(null, s)
        );
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.split_at = function cljs$core$split_at(n, coll) {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.take.cljs$core$IFn$_invoke$arity$2(n, coll),
      cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n, coll)
    ],
    null
  );
};
cljs.core.repeat = function cljs$core$repeat(var_args) {
  var args11035 = [];
  var len__8257__auto___11038 = arguments.length;
  var i__8258__auto___11039 = 0;
  while (true) {
    if (i__8258__auto___11039 < len__8257__auto___11038) {
      args11035.push(arguments[i__8258__auto___11039]);
      var G__11040 = i__8258__auto___11039 + 1;
      i__8258__auto___11039 = G__11040;
      continue;
    } else;
    break;
  }
  var G__11037 = args11035.length;
  switch (G__11037) {
    case 1:
      return cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11035.length)
        ].join('')
      );
  }
};
cljs.core.repeat.cljs$core$IFn$_invoke$arity$1 = function(x) {
  return new cljs.core.LazySeq(
    null,
    function() {
      return cljs.core.cons(
        x,
        cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(x)
      );
    },
    null,
    null
  );
};
cljs.core.repeat.cljs$core$IFn$_invoke$arity$2 = function(n, x) {
  return cljs.core.take.cljs$core$IFn$_invoke$arity$2(
    n,
    cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(x)
  );
};
cljs.core.repeat.cljs$lang$maxFixedArity = 2;
cljs.core.replicate = function cljs$core$replicate(n, x) {
  return cljs.core.take.cljs$core$IFn$_invoke$arity$2(
    n,
    cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(x)
  );
};
cljs.core.repeatedly = function cljs$core$repeatedly(var_args) {
  var args11042 = [];
  var len__8257__auto___11045 = arguments.length;
  var i__8258__auto___11046 = 0;
  while (true) {
    if (i__8258__auto___11046 < len__8257__auto___11045) {
      args11042.push(arguments[i__8258__auto___11046]);
      var G__11047 = i__8258__auto___11046 + 1;
      i__8258__auto___11046 = G__11047;
      continue;
    } else;
    break;
  }
  var G__11044 = args11042.length;
  switch (G__11044) {
    case 1:
      return cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11042.length)
        ].join('')
      );
  }
};
cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return new cljs.core.LazySeq(
    null,
    function() {
      return cljs.core.cons(
        f.cljs$core$IFn$_invoke$arity$0
          ? f.cljs$core$IFn$_invoke$arity$0()
          : f.call(null),
        cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(f)
      );
    },
    null,
    null
  );
};
cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2 = function(n, f) {
  return cljs.core.take.cljs$core$IFn$_invoke$arity$2(
    n,
    cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(f)
  );
};
cljs.core.repeatedly.cljs$lang$maxFixedArity = 2;
cljs.core.iterate = function cljs$core$iterate(f, x) {
  return cljs.core.cons(
    x,
    new cljs.core.LazySeq(
      null,
      function() {
        var G__11051 = f;
        var G__11052 = f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(x)
          : f.call(null, x);
        return cljs.core.iterate.cljs$core$IFn$_invoke$arity$2
          ? cljs.core.iterate.cljs$core$IFn$_invoke$arity$2(G__11051, G__11052)
          : cljs.core.iterate.call(null, G__11051, G__11052);
      },
      null,
      null
    )
  );
};
cljs.core.interleave = function cljs$core$interleave(var_args) {
  var args11053 = [];
  var len__8257__auto___11059 = arguments.length;
  var i__8258__auto___11060 = 0;
  while (true) {
    if (i__8258__auto___11060 < len__8257__auto___11059) {
      args11053.push(arguments[i__8258__auto___11060]);
      var G__11061 = i__8258__auto___11060 + 1;
      i__8258__auto___11060 = G__11061;
      continue;
    } else;
    break;
  }
  var G__11058 = args11053.length;
  switch (G__11058) {
    case 2:
      return cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args11053.slice(2),
        0,
        null
      );
      return cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        argseq__8276__auto__
      );
  }
};
cljs.core.interleave.cljs$core$IFn$_invoke$arity$2 = function(c1, c2) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var s1 = cljs.core.seq(c1);
      var s2 = cljs.core.seq(c2);
      if (s1 && s2)
        return cljs.core.cons(
          cljs.core.first(s1),
          cljs.core.cons(
            cljs.core.first(s2),
            cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(
              cljs.core.rest(s1),
              cljs.core.rest(s2)
            )
          )
        );
      else
        return null;
    },
    null,
    null
  );
};
cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic = function(
  c1,
  c2,
  colls
) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var ss = cljs.core.map.cljs$core$IFn$_invoke$arity$2(
        cljs.core.seq,
        cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(
          colls,
          c2,
          cljs.core.array_seq([c1], 0)
        )
      );
      if (cljs.core.every_QMARK_(cljs.core.identity, ss))
        return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(
          cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first, ss),
          cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
            cljs.core.interleave,
            cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.rest, ss)
          )
        );
      else
        return null;
    },
    null,
    null
  );
};
cljs.core.interleave.cljs$lang$applyTo = function(seq11054) {
  var G__11055 = cljs.core.first(seq11054);
  var seq11054__$1 = cljs.core.next(seq11054);
  var G__11056 = cljs.core.first(seq11054__$1);
  var seq11054__$2 = cljs.core.next(seq11054__$1);
  return cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic(
    G__11055,
    G__11056,
    seq11054__$2
  );
};
cljs.core.interleave.cljs$lang$maxFixedArity = 2;
cljs.core.interpose = function cljs$core$interpose(var_args) {
  var args11063 = [];
  var len__8257__auto___11066 = arguments.length;
  var i__8258__auto___11067 = 0;
  while (true) {
    if (i__8258__auto___11067 < len__8257__auto___11066) {
      args11063.push(arguments[i__8258__auto___11067]);
      var G__11068 = i__8258__auto___11067 + 1;
      i__8258__auto___11067 = G__11068;
      continue;
    } else;
    break;
  }
  var G__11065 = args11063.length;
  switch (G__11065) {
    case 1:
      return cljs.core.interpose.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11063.length)
        ].join('')
      );
  }
};
cljs.core.interpose.cljs$core$IFn$_invoke$arity$1 = function(sep) {
  return function(rf) {
    var started = cljs.core.volatile_BANG_(false);
    return (function(started) {
      return (function() {
        var G__11070 = null;
        var G__11070__0 = function() {
          return rf.cljs$core$IFn$_invoke$arity$0
            ? rf.cljs$core$IFn$_invoke$arity$0()
            : rf.call(null);
        };
        var G__11070__1 = function(result) {
          return rf.cljs$core$IFn$_invoke$arity$1
            ? rf.cljs$core$IFn$_invoke$arity$1(result)
            : rf.call(null, result);
        };
        var G__11070__2 = function(result, input) {
          if (cljs.core.truth_(cljs.core.deref(started))) {
            var sepr = rf.cljs$core$IFn$_invoke$arity$2
              ? rf.cljs$core$IFn$_invoke$arity$2(result, sep)
              : rf.call(null, result, sep);
            if (cljs.core.reduced_QMARK_(sepr)) return sepr;
            else return rf.cljs$core$IFn$_invoke$arity$2
                ? rf.cljs$core$IFn$_invoke$arity$2(sepr, input)
                : rf.call(null, sepr, input);
          } else {
            cljs.core.vreset_BANG_(started, true);
            return rf.cljs$core$IFn$_invoke$arity$2
              ? rf.cljs$core$IFn$_invoke$arity$2(result, input)
              : rf.call(null, result, input);
          }
        };
        G__11070 = function(result, input) {
          switch (arguments.length) {
            case 0:
              return G__11070__0.call(this);
            case 1:
              return G__11070__1.call(this, result);
            case 2:
              return G__11070__2.call(this, result, input);
          }
          throw new Error('Invalid arity: ' + arguments.length);
        };
        G__11070.cljs$core$IFn$_invoke$arity$0 = G__11070__0;
        G__11070.cljs$core$IFn$_invoke$arity$1 = G__11070__1;
        G__11070.cljs$core$IFn$_invoke$arity$2 = G__11070__2;
        return G__11070;
      })();
    })(started);
  };
};
cljs.core.interpose.cljs$core$IFn$_invoke$arity$2 = function(sep, coll) {
  return cljs.core.drop.cljs$core$IFn$_invoke$arity$2(
    1,
    cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(
      cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(sep),
      coll
    )
  );
};
cljs.core.interpose.cljs$lang$maxFixedArity = 2;
cljs.core.flatten1 = function cljs$core$flatten1(colls) {
  var cat = function cljs$core$flatten1_$_cat(coll, colls__$1) {
    return new cljs.core.LazySeq(
      null,
      function() {
        var temp__4655__auto__ = cljs.core.seq(coll);
        if (temp__4655__auto__) {
          var coll__$1 = temp__4655__auto__;
          return cljs.core.cons(
            cljs.core.first(coll__$1),
            cljs$core$flatten1_$_cat(cljs.core.rest(coll__$1), colls__$1)
          );
        } else if (cljs.core.seq(colls__$1))
          return cljs$core$flatten1_$_cat(
            cljs.core.first(colls__$1),
            cljs.core.rest(colls__$1)
          );
        else
          return null;
      },
      null,
      null
    );
  };
  return cat(null, colls);
};
cljs.core.mapcat = function cljs$core$mapcat(var_args) {
  var args11079 = [];
  var len__8257__auto___11084 = arguments.length;
  var i__8258__auto___11085 = 0;
  while (true) {
    if (i__8258__auto___11085 < len__8257__auto___11084) {
      args11079.push(arguments[i__8258__auto___11085]);
      var G__11086 = i__8258__auto___11085 + 1;
      i__8258__auto___11085 = G__11086;
      continue;
    } else;
    break;
  }
  var G__11083 = args11079.length;
  switch (G__11083) {
    case 1:
      return cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args11079.slice(1),
        0,
        null
      );
      return cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        argseq__8276__auto__
      );
  }
};
cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1 = function(f) {
  return cljs.core.comp.cljs$core$IFn$_invoke$arity$2(
    cljs.core.map.cljs$core$IFn$_invoke$arity$1(f),
    cljs.core.cat
  );
};
cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic = function(f, colls) {
  return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(
    cljs.core.concat,
    cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.map, f, colls)
  );
};
cljs.core.mapcat.cljs$lang$applyTo = function(seq11080) {
  var G__11081 = cljs.core.first(seq11080);
  var seq11080__$1 = cljs.core.next(seq11080);
  return cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(
    G__11081,
    seq11080__$1
  );
};
cljs.core.mapcat.cljs$lang$maxFixedArity = 1;
cljs.core.filter = function cljs$core$filter(var_args) {
  var args11088 = [];
  var len__8257__auto___11092 = arguments.length;
  var i__8258__auto___11093 = 0;
  while (true) {
    if (i__8258__auto___11093 < len__8257__auto___11092) {
      args11088.push(arguments[i__8258__auto___11093]);
      var G__11094 = i__8258__auto___11093 + 1;
      i__8258__auto___11093 = G__11094;
      continue;
    } else;
    break;
  }
  var G__11090 = args11088.length;
  switch (G__11090) {
    case 1:
      return cljs.core.filter.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11088.length)
        ].join('')
      );
  }
};
cljs.core.filter.cljs$core$IFn$_invoke$arity$1 = function(pred) {
  return function(rf) {
    return (function() {
      var G__11096 = null;
      var G__11096__0 = function() {
        return rf.cljs$core$IFn$_invoke$arity$0
          ? rf.cljs$core$IFn$_invoke$arity$0()
          : rf.call(null);
      };
      var G__11096__1 = function(result) {
        return rf.cljs$core$IFn$_invoke$arity$1
          ? rf.cljs$core$IFn$_invoke$arity$1(result)
          : rf.call(null, result);
      };
      var G__11096__2 = function(result, input) {
        if (
          cljs.core.truth_(
            pred.cljs$core$IFn$_invoke$arity$1
              ? pred.cljs$core$IFn$_invoke$arity$1(input)
              : pred.call(null, input)
          )
        )
          return rf.cljs$core$IFn$_invoke$arity$2
            ? rf.cljs$core$IFn$_invoke$arity$2(result, input)
            : rf.call(null, result, input);
        else
          return result;
      };
      G__11096 = function(result, input) {
        switch (arguments.length) {
          case 0:
            return G__11096__0.call(this);
          case 1:
            return G__11096__1.call(this, result);
          case 2:
            return G__11096__2.call(this, result, input);
        }
        throw new Error('Invalid arity: ' + arguments.length);
      };
      G__11096.cljs$core$IFn$_invoke$arity$0 = G__11096__0;
      G__11096.cljs$core$IFn$_invoke$arity$1 = G__11096__1;
      G__11096.cljs$core$IFn$_invoke$arity$2 = G__11096__2;
      return G__11096;
    })();
  };
};
cljs.core.filter.cljs$core$IFn$_invoke$arity$2 = function(pred, coll) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        if (cljs.core.chunked_seq_QMARK_(s)) {
          var c = cljs.core.chunk_first(s);
          var size = cljs.core.count(c);
          var b = cljs.core.chunk_buffer(size);
          var n__8067__auto___11097 = size;
          var i_11098 = 0;
          while (true) {
            if (i_11098 < n__8067__auto___11097) {
              if (
                cljs.core.truth_(
                  (function() {
                    var G__11091 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
                      c,
                      i_11098
                    );
                    return pred.cljs$core$IFn$_invoke$arity$1
                      ? pred.cljs$core$IFn$_invoke$arity$1(G__11091)
                      : pred.call(null, G__11091);
                  })()
                )
              )
                cljs.core.chunk_append(
                  b,
                  cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c, i_11098)
                );
              else;
              var G__11099 = i_11098 + 1;
              i_11098 = G__11099;
              continue;
            } else;
            break;
          }
          return cljs.core.chunk_cons(
            cljs.core.chunk(b),
            cljs.core.filter.cljs$core$IFn$_invoke$arity$2(
              pred,
              cljs.core.chunk_rest(s)
            )
          );
        } else {
          var f = cljs.core.first(s);
          var r = cljs.core.rest(s);
          if (
            cljs.core.truth_(
              pred.cljs$core$IFn$_invoke$arity$1
                ? pred.cljs$core$IFn$_invoke$arity$1(f)
                : pred.call(null, f)
            )
          )
            return cljs.core.cons(
              f,
              cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred, r)
            );
          else
            return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred, r);
        }
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.filter.cljs$lang$maxFixedArity = 2;
cljs.core.remove = function cljs$core$remove(var_args) {
  var args11100 = [];
  var len__8257__auto___11103 = arguments.length;
  var i__8258__auto___11104 = 0;
  while (true) {
    if (i__8258__auto___11104 < len__8257__auto___11103) {
      args11100.push(arguments[i__8258__auto___11104]);
      var G__11105 = i__8258__auto___11104 + 1;
      i__8258__auto___11104 = G__11105;
      continue;
    } else;
    break;
  }
  var G__11102 = args11100.length;
  switch (G__11102) {
    case 1:
      return cljs.core.remove.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.remove.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11100.length)
        ].join('')
      );
  }
};
cljs.core.remove.cljs$core$IFn$_invoke$arity$1 = function(pred) {
  return cljs.core.filter.cljs$core$IFn$_invoke$arity$1(
    cljs.core.complement(pred)
  );
};
cljs.core.remove.cljs$core$IFn$_invoke$arity$2 = function(pred, coll) {
  return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(
    cljs.core.complement(pred),
    coll
  );
};
cljs.core.remove.cljs$lang$maxFixedArity = 2;
cljs.core.tree_seq = function cljs$core$tree_seq(
  branch_QMARK_,
  children,
  root
) {
  var walk = function cljs$core$tree_seq_$_walk(node) {
    return new cljs.core.LazySeq(
      null,
      function() {
        return cljs.core.cons(
          node,
          cljs.core.truth_(
            branch_QMARK_.cljs$core$IFn$_invoke$arity$1
              ? branch_QMARK_.cljs$core$IFn$_invoke$arity$1(node)
              : branch_QMARK_.call(null, node)
          )
            ? cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(
                cljs$core$tree_seq_$_walk,
                cljs.core.array_seq(
                  [
                    children.cljs$core$IFn$_invoke$arity$1
                      ? children.cljs$core$IFn$_invoke$arity$1(node)
                      : children.call(null, node)
                  ],
                  0
                )
              )
            : null
        );
      },
      null,
      null
    );
  };
  return walk(root);
};
cljs.core.flatten = function cljs$core$flatten(x) {
  return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(
    function(p1__11107_SHARP_) {
      return !cljs.core.sequential_QMARK_(p1__11107_SHARP_);
    },
    cljs.core.rest(
      cljs.core.tree_seq(cljs.core.sequential_QMARK_, cljs.core.seq, x)
    )
  );
};
cljs.core.into = function cljs$core$into(var_args) {
  var args11108 = [];
  var len__8257__auto___11113 = arguments.length;
  var i__8258__auto___11114 = 0;
  while (true) {
    if (i__8258__auto___11114 < len__8257__auto___11113) {
      args11108.push(arguments[i__8258__auto___11114]);
      var G__11115 = i__8258__auto___11114 + 1;
      i__8258__auto___11114 = G__11115;
      continue;
    } else;
    break;
  }
  var G__11110 = args11108.length;
  switch (G__11110) {
    case 0:
      return cljs.core.into.cljs$core$IFn$_invoke$arity$0();
      break;
    case 1:
      return cljs.core.into.cljs$core$IFn$_invoke$arity$1(arguments[0]);
      break;
    case 2:
      return cljs.core.into.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.into.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11108.length)
        ].join('')
      );
  }
};
cljs.core.into.cljs$core$IFn$_invoke$arity$0 = function() {
  return cljs.core.PersistentVector.EMPTY;
};
cljs.core.into.cljs$core$IFn$_invoke$arity$1 = function(to) {
  return to;
};
cljs.core.into.cljs$core$IFn$_invoke$arity$2 = function(to, from) {
  if (!(to == null))
    if (
      !(to == null)
        ? to.cljs$lang$protocol_mask$partition1$ & 4 ||
            cljs.core.PROTOCOL_SENTINEL === to.cljs$core$IEditableCollection$
            ? true
            : false
        : false
    )
      return cljs.core.with_meta(
        cljs.core.persistent_BANG_(
          cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
            cljs.core._conj_BANG_,
            cljs.core.transient$(to),
            from
          )
        ),
        cljs.core.meta(to)
      );
    else
      return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
        cljs.core._conj,
        to,
        from
      );
  else
    return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
      cljs.core.conj,
      cljs.core.List.EMPTY,
      from
    );
};
cljs.core.into.cljs$core$IFn$_invoke$arity$3 = function(to, xform, from) {
  if (
    !(to == null)
      ? to.cljs$lang$protocol_mask$partition1$ & 4 ||
          cljs.core.PROTOCOL_SENTINEL === to.cljs$core$IEditableCollection$
          ? true
          : false
      : false
  )
    return cljs.core.with_meta(
      cljs.core.persistent_BANG_(
        cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(
          xform,
          cljs.core.conj_BANG_,
          cljs.core.transient$(to),
          from
        )
      ),
      cljs.core.meta(to)
    );
  else
    return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(
      xform,
      cljs.core.conj,
      to,
      from
    );
};
cljs.core.into.cljs$lang$maxFixedArity = 3;
cljs.core.mapv = function cljs$core$mapv(var_args) {
  var args11117 = [];
  var len__8257__auto___11125 = arguments.length;
  var i__8258__auto___11126 = 0;
  while (true) {
    if (i__8258__auto___11126 < len__8257__auto___11125) {
      args11117.push(arguments[i__8258__auto___11126]);
      var G__11127 = i__8258__auto___11126 + 1;
      i__8258__auto___11126 = G__11127;
      continue;
    } else;
    break;
  }
  var G__11124 = args11117.length;
  switch (G__11124) {
    case 2:
      return cljs.core.mapv.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.mapv.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.mapv.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args11117.slice(4),
        0,
        null
      );
      return cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        argseq__8276__auto__
      );
  }
};
cljs.core.mapv.cljs$core$IFn$_invoke$arity$2 = function(f, coll) {
  return cljs.core.persistent_BANG_(
    cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
      function(v, o) {
        return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(
          v,
          f.cljs$core$IFn$_invoke$arity$1
            ? f.cljs$core$IFn$_invoke$arity$1(o)
            : f.call(null, o)
        );
      },
      cljs.core.transient$(cljs.core.PersistentVector.EMPTY),
      coll
    )
  );
};
cljs.core.mapv.cljs$core$IFn$_invoke$arity$3 = function(f, c1, c2) {
  return cljs.core.into.cljs$core$IFn$_invoke$arity$2(
    cljs.core.PersistentVector.EMPTY,
    cljs.core.map.cljs$core$IFn$_invoke$arity$3(f, c1, c2)
  );
};
cljs.core.mapv.cljs$core$IFn$_invoke$arity$4 = function(f, c1, c2, c3) {
  return cljs.core.into.cljs$core$IFn$_invoke$arity$2(
    cljs.core.PersistentVector.EMPTY,
    cljs.core.map.cljs$core$IFn$_invoke$arity$4(f, c1, c2, c3)
  );
};
cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic = function(
  f,
  c1,
  c2,
  c3,
  colls
) {
  return cljs.core.into.cljs$core$IFn$_invoke$arity$2(
    cljs.core.PersistentVector.EMPTY,
    cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
      cljs.core.map,
      f,
      c1,
      c2,
      c3,
      cljs.core.array_seq([colls], 0)
    )
  );
};
cljs.core.mapv.cljs$lang$applyTo = function(seq11118) {
  var G__11119 = cljs.core.first(seq11118);
  var seq11118__$1 = cljs.core.next(seq11118);
  var G__11120 = cljs.core.first(seq11118__$1);
  var seq11118__$2 = cljs.core.next(seq11118__$1);
  var G__11121 = cljs.core.first(seq11118__$2);
  var seq11118__$3 = cljs.core.next(seq11118__$2);
  var G__11122 = cljs.core.first(seq11118__$3);
  var seq11118__$4 = cljs.core.next(seq11118__$3);
  return cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic(
    G__11119,
    G__11120,
    G__11121,
    G__11122,
    seq11118__$4
  );
};
cljs.core.mapv.cljs$lang$maxFixedArity = 4;
cljs.core.filterv = function cljs$core$filterv(pred, coll) {
  return cljs.core.persistent_BANG_(
    cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
      function(v, o) {
        if (
          cljs.core.truth_(
            pred.cljs$core$IFn$_invoke$arity$1
              ? pred.cljs$core$IFn$_invoke$arity$1(o)
              : pred.call(null, o)
          )
        )
          return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v, o);
        else
          return v;
      },
      cljs.core.transient$(cljs.core.PersistentVector.EMPTY),
      coll
    )
  );
};
cljs.core.partition = function cljs$core$partition(var_args) {
  var args11129 = [];
  var len__8257__auto___11132 = arguments.length;
  var i__8258__auto___11133 = 0;
  while (true) {
    if (i__8258__auto___11133 < len__8257__auto___11132) {
      args11129.push(arguments[i__8258__auto___11133]);
      var G__11134 = i__8258__auto___11133 + 1;
      i__8258__auto___11133 = G__11134;
      continue;
    } else;
    break;
  }
  var G__11131 = args11129.length;
  switch (G__11131) {
    case 2:
      return cljs.core.partition.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.partition.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.partition.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11129.length)
        ].join('')
      );
  }
};
cljs.core.partition.cljs$core$IFn$_invoke$arity$2 = function(n, coll) {
  return cljs.core.partition.cljs$core$IFn$_invoke$arity$3(n, n, coll);
};
cljs.core.partition.cljs$core$IFn$_invoke$arity$3 = function(n, step, coll) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        var p = cljs.core.take.cljs$core$IFn$_invoke$arity$2(n, s);
        if (n === cljs.core.count(p))
          return cljs.core.cons(
            p,
            cljs.core.partition.cljs$core$IFn$_invoke$arity$3(
              n,
              step,
              cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step, s)
            )
          );
        else
          return null;
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.partition.cljs$core$IFn$_invoke$arity$4 = function(
  n,
  step,
  pad,
  coll
) {
  return new cljs.core.LazySeq(
    null,
    function() {
      var temp__4657__auto__ = cljs.core.seq(coll);
      if (temp__4657__auto__) {
        var s = temp__4657__auto__;
        var p = cljs.core.take.cljs$core$IFn$_invoke$arity$2(n, s);
        if (n === cljs.core.count(p))
          return cljs.core.cons(
            p,
            cljs.core.partition.cljs$core$IFn$_invoke$arity$4(
              n,
              step,
              pad,
              cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step, s)
            )
          );
        else {
          var x__7986__auto__ = cljs.core.take.cljs$core$IFn$_invoke$arity$2(
            n,
            cljs.core.concat.cljs$core$IFn$_invoke$arity$2(p, pad)
          );
          return cljs.core._conj(cljs.core.List.EMPTY, x__7986__auto__);
        }
      } else
        return null;
    },
    null,
    null
  );
};
cljs.core.partition.cljs$lang$maxFixedArity = 4;
cljs.core.get_in = function cljs$core$get_in(var_args) {
  var args11136 = [];
  var len__8257__auto___11139 = arguments.length;
  var i__8258__auto___11140 = 0;
  while (true) {
    if (i__8258__auto___11140 < len__8257__auto___11139) {
      args11136.push(arguments[i__8258__auto___11140]);
      var G__11141 = i__8258__auto___11140 + 1;
      i__8258__auto___11140 = G__11141;
      continue;
    } else;
    break;
  }
  var G__11138 = args11136.length;
  switch (G__11138) {
    case 2:
      return cljs.core.get_in.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.get_in.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11136.length)
        ].join('')
      );
  }
};
cljs.core.get_in.cljs$core$IFn$_invoke$arity$2 = function(m, ks) {
  return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.get, m, ks);
};
cljs.core.get_in.cljs$core$IFn$_invoke$arity$3 = function(m, ks, not_found) {
  var sentinel = cljs.core.lookup_sentinel;
  var m__$1 = m;
  var ks__$1 = cljs.core.seq(ks);
  while (true) {
    if (!(ks__$1 == null)) {
      var m__$2 = cljs.core.get.cljs$core$IFn$_invoke$arity$3(
        m__$1,
        cljs.core.first(ks__$1),
        sentinel
      );
      if (sentinel === m__$2)
        return not_found;
      else {
        var G__11143 = sentinel;
        var G__11144 = m__$2;
        var G__11145 = cljs.core.next(ks__$1);
        sentinel = G__11143;
        m__$1 = G__11144;
        ks__$1 = G__11145;
        continue;
      }
    } else
      return m__$1;
    break;
  }
};
cljs.core.get_in.cljs$lang$maxFixedArity = 3;
cljs.core.assoc_in = function cljs$core$assoc_in(m, p__11146, v) {
  var vec__11153 = p__11146;
  var seq__11154 = cljs.core.seq(vec__11153);
  var first__11155 = cljs.core.first(seq__11154);
  var seq__11154__$1 = cljs.core.next(seq__11154);
  var k = first__11155;
  var ks = seq__11154__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      (function() {
        var G__11156 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
        var G__11157 = ks;
        var G__11158 = v;
        return cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3
          ? cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3(
              G__11156,
              G__11157,
              G__11158
            )
          : cljs.core.assoc_in.call(null, G__11156, G__11157, G__11158);
      })()
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m, k, v);
};
cljs.core.update_in = function cljs$core$update_in(var_args) {
  var args11159 = [];
  var len__8257__auto___11199 = arguments.length;
  var i__8258__auto___11200 = 0;
  while (true) {
    if (i__8258__auto___11200 < len__8257__auto___11199) {
      args11159.push(arguments[i__8258__auto___11200]);
      var G__11201 = i__8258__auto___11200 + 1;
      i__8258__auto___11200 = G__11201;
      continue;
    } else;
    break;
  }
  var G__11168 = args11159.length;
  switch (G__11168) {
    case 3:
      return cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core.update_in.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    case 6:
      return cljs.core.update_in.cljs$core$IFn$_invoke$arity$6(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args11159.slice(6),
        0,
        null
      );
      return cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        argseq__8276__auto__
      );
  }
};
cljs.core.update_in.cljs$core$IFn$_invoke$arity$3 = function(m, p__11169, f) {
  var vec__11170 = p__11169;
  var seq__11171 = cljs.core.seq(vec__11170);
  var first__11172 = cljs.core.first(seq__11171);
  var seq__11171__$1 = cljs.core.next(seq__11171);
  var k = first__11172;
  var ks = seq__11171__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        ks,
        f
      )
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      (function() {
        var G__11173 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
        return f.cljs$core$IFn$_invoke$arity$1
          ? f.cljs$core$IFn$_invoke$arity$1(G__11173)
          : f.call(null, G__11173);
      })()
    );
};
cljs.core.update_in.cljs$core$IFn$_invoke$arity$4 = function(
  m,
  p__11174,
  f,
  a
) {
  var vec__11175 = p__11174;
  var seq__11176 = cljs.core.seq(vec__11175);
  var first__11177 = cljs.core.first(seq__11176);
  var seq__11176__$1 = cljs.core.next(seq__11176);
  var k = first__11177;
  var ks = seq__11176__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        ks,
        f,
        a
      )
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      (function() {
        var G__11178 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
        var G__11179 = a;
        return f.cljs$core$IFn$_invoke$arity$2
          ? f.cljs$core$IFn$_invoke$arity$2(G__11178, G__11179)
          : f.call(null, G__11178, G__11179);
      })()
    );
};
cljs.core.update_in.cljs$core$IFn$_invoke$arity$5 = function(
  m,
  p__11180,
  f,
  a,
  b
) {
  var vec__11181 = p__11180;
  var seq__11182 = cljs.core.seq(vec__11181);
  var first__11183 = cljs.core.first(seq__11182);
  var seq__11182__$1 = cljs.core.next(seq__11182);
  var k = first__11183;
  var ks = seq__11182__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.update_in.cljs$core$IFn$_invoke$arity$5(
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        ks,
        f,
        a,
        b
      )
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      (function() {
        var G__11184 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
        var G__11185 = a;
        var G__11186 = b;
        return f.cljs$core$IFn$_invoke$arity$3
          ? f.cljs$core$IFn$_invoke$arity$3(G__11184, G__11185, G__11186)
          : f.call(null, G__11184, G__11185, G__11186);
      })()
    );
};
cljs.core.update_in.cljs$core$IFn$_invoke$arity$6 = function(
  m,
  p__11187,
  f,
  a,
  b,
  c
) {
  var vec__11188 = p__11187;
  var seq__11189 = cljs.core.seq(vec__11188);
  var first__11190 = cljs.core.first(seq__11189);
  var seq__11189__$1 = cljs.core.next(seq__11189);
  var k = first__11190;
  var ks = seq__11189__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.update_in.cljs$core$IFn$_invoke$arity$6(
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        ks,
        f,
        a,
        b,
        c
      )
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      (function() {
        var G__11191 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
        var G__11192 = a;
        var G__11193 = b;
        var G__11194 = c;
        return f.cljs$core$IFn$_invoke$arity$4
          ? f.cljs$core$IFn$_invoke$arity$4(
              G__11191,
              G__11192,
              G__11193,
              G__11194
            )
          : f.call(null, G__11191, G__11192, G__11193, G__11194);
      })()
    );
};
cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic = function(
  m,
  p__11195,
  f,
  a,
  b,
  c,
  args
) {
  var vec__11196 = p__11195;
  var seq__11197 = cljs.core.seq(vec__11196);
  var first__11198 = cljs.core.first(seq__11197);
  var seq__11197__$1 = cljs.core.next(seq__11197);
  var k = first__11198;
  var ks = seq__11197__$1;
  if (ks)
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
        cljs.core.update_in,
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        ks,
        f,
        a,
        cljs.core.array_seq([b, c, args], 0)
      )
    );
  else
    return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      m,
      k,
      cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
        f,
        cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
        a,
        b,
        c,
        cljs.core.array_seq([args], 0)
      )
    );
};
cljs.core.update_in.cljs$lang$applyTo = function(seq11160) {
  var G__11161 = cljs.core.first(seq11160);
  var seq11160__$1 = cljs.core.next(seq11160);
  var G__11162 = cljs.core.first(seq11160__$1);
  var seq11160__$2 = cljs.core.next(seq11160__$1);
  var G__11163 = cljs.core.first(seq11160__$2);
  var seq11160__$3 = cljs.core.next(seq11160__$2);
  var G__11164 = cljs.core.first(seq11160__$3);
  var seq11160__$4 = cljs.core.next(seq11160__$3);
  var G__11165 = cljs.core.first(seq11160__$4);
  var seq11160__$5 = cljs.core.next(seq11160__$4);
  var G__11166 = cljs.core.first(seq11160__$5);
  var seq11160__$6 = cljs.core.next(seq11160__$5);
  return cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic(
    G__11161,
    G__11162,
    G__11163,
    G__11164,
    G__11165,
    G__11166,
    seq11160__$6
  );
};
cljs.core.update_in.cljs$lang$maxFixedArity = 6;
cljs.core.update = function cljs$core$update(var_args) {
  var args11203 = [];
  var len__8257__auto___11223 = arguments.length;
  var i__8258__auto___11224 = 0;
  while (true) {
    if (i__8258__auto___11224 < len__8257__auto___11223) {
      args11203.push(arguments[i__8258__auto___11224]);
      var G__11225 = i__8258__auto___11224 + 1;
      i__8258__auto___11224 = G__11225;
      continue;
    } else;
    break;
  }
  var G__11212 = args11203.length;
  switch (G__11212) {
    case 3:
      return cljs.core.update.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.update.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core.update.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    case 6:
      return cljs.core.update.cljs$core$IFn$_invoke$arity$6(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5]
      );
      break;
    default:
      var argseq__8276__auto__ = new cljs.core.IndexedSeq(
        args11203.slice(6),
        0,
        null
      );
      return cljs.core.update.cljs$core$IFn$_invoke$arity$variadic(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4],
        arguments[5],
        argseq__8276__auto__
      );
  }
};
cljs.core.update.cljs$core$IFn$_invoke$arity$3 = function(m, k, f) {
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    m,
    k,
    (function() {
      var G__11213 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
      return f.cljs$core$IFn$_invoke$arity$1
        ? f.cljs$core$IFn$_invoke$arity$1(G__11213)
        : f.call(null, G__11213);
    })()
  );
};
cljs.core.update.cljs$core$IFn$_invoke$arity$4 = function(m, k, f, x) {
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    m,
    k,
    (function() {
      var G__11214 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
      var G__11215 = x;
      return f.cljs$core$IFn$_invoke$arity$2
        ? f.cljs$core$IFn$_invoke$arity$2(G__11214, G__11215)
        : f.call(null, G__11214, G__11215);
    })()
  );
};
cljs.core.update.cljs$core$IFn$_invoke$arity$5 = function(m, k, f, x, y) {
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    m,
    k,
    (function() {
      var G__11216 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
      var G__11217 = x;
      var G__11218 = y;
      return f.cljs$core$IFn$_invoke$arity$3
        ? f.cljs$core$IFn$_invoke$arity$3(G__11216, G__11217, G__11218)
        : f.call(null, G__11216, G__11217, G__11218);
    })()
  );
};
cljs.core.update.cljs$core$IFn$_invoke$arity$6 = function(m, k, f, x, y, z) {
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    m,
    k,
    (function() {
      var G__11219 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k);
      var G__11220 = x;
      var G__11221 = y;
      var G__11222 = z;
      return f.cljs$core$IFn$_invoke$arity$4
        ? f.cljs$core$IFn$_invoke$arity$4(
            G__11219,
            G__11220,
            G__11221,
            G__11222
          )
        : f.call(null, G__11219, G__11220, G__11221, G__11222);
    })()
  );
};
cljs.core.update.cljs$core$IFn$_invoke$arity$variadic = function(
  m,
  k,
  f,
  x,
  y,
  z,
  more
) {
  return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
    m,
    k,
    cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(
      f,
      cljs.core.get.cljs$core$IFn$_invoke$arity$2(m, k),
      x,
      y,
      z,
      cljs.core.array_seq([more], 0)
    )
  );
};
cljs.core.update.cljs$lang$applyTo = function(seq11204) {
  var G__11205 = cljs.core.first(seq11204);
  var seq11204__$1 = cljs.core.next(seq11204);
  var G__11206 = cljs.core.first(seq11204__$1);
  var seq11204__$2 = cljs.core.next(seq11204__$1);
  var G__11207 = cljs.core.first(seq11204__$2);
  var seq11204__$3 = cljs.core.next(seq11204__$2);
  var G__11208 = cljs.core.first(seq11204__$3);
  var seq11204__$4 = cljs.core.next(seq11204__$3);
  var G__11209 = cljs.core.first(seq11204__$4);
  var seq11204__$5 = cljs.core.next(seq11204__$4);
  var G__11210 = cljs.core.first(seq11204__$5);
  var seq11204__$6 = cljs.core.next(seq11204__$5);
  return cljs.core.update.cljs$core$IFn$_invoke$arity$variadic(
    G__11205,
    G__11206,
    G__11207,
    G__11208,
    G__11209,
    G__11210,
    seq11204__$6
  );
};
cljs.core.update.cljs$lang$maxFixedArity = 6;
cljs.core.VectorNode = function(edit, arr) {
  this.edit = edit;
  this.arr = arr;
};
cljs.core.VectorNode.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'edit', 'edit', -1302639, null),
      new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null)
    ],
    null
  );
};
cljs.core.VectorNode.cljs$lang$type = true;
cljs.core.VectorNode.cljs$lang$ctorStr = 'cljs.core/VectorNode';
cljs.core.VectorNode.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/VectorNode');
};
cljs.core.__GT_VectorNode = function cljs$core$__GT_VectorNode(edit, arr) {
  return new cljs.core.VectorNode(edit, arr);
};
cljs.core.pv_fresh_node = function cljs$core$pv_fresh_node(edit) {
  return new cljs.core.VectorNode(edit, [
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null
  ]);
};
cljs.core.pv_aget = function cljs$core$pv_aget(node, idx) {
  return node.arr[idx];
};
cljs.core.pv_aset = function cljs$core$pv_aset(node, idx, val) {
  return (node.arr[idx] = val);
};
cljs.core.pv_clone_node = function cljs$core$pv_clone_node(node) {
  return new cljs.core.VectorNode(node.edit, cljs.core.aclone(node.arr));
};
cljs.core.tail_off = function cljs$core$tail_off(pv) {
  var cnt = pv.cnt;
  if (cnt < 32) return 0;
  else return cnt - 1 >>> 5 << 5;
};
cljs.core.new_path = function cljs$core$new_path(edit, level, node) {
  var ll = level;
  var ret = node;
  while (true) {
    if (ll === 0)
      return ret;
    else {
      var embed = ret;
      var r = cljs.core.pv_fresh_node(edit);
      var _ = cljs.core.pv_aset(r, 0, embed);
      var G__11227 = ll - 5;
      var G__11228 = r;
      ll = G__11227;
      ret = G__11228;
      continue;
    }
    break;
  }
};
cljs.core.push_tail = function cljs$core$push_tail(
  pv,
  level,
  parent,
  tailnode
) {
  var ret = cljs.core.pv_clone_node(parent);
  var subidx = pv.cnt - 1 >>> level & 31;
  if (5 === level) {
    cljs.core.pv_aset(ret, subidx, tailnode);
    return ret;
  } else {
    var child = cljs.core.pv_aget(parent, subidx);
    if (!(child == null)) {
      var node_to_insert = (function() {
        var G__11233 = pv;
        var G__11234 = level - 5;
        var G__11235 = child;
        var G__11236 = tailnode;
        return cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4
          ? cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4(
              G__11233,
              G__11234,
              G__11235,
              G__11236
            )
          : cljs.core.push_tail.call(
              null,
              G__11233,
              G__11234,
              G__11235,
              G__11236
            );
      })();
      cljs.core.pv_aset(ret, subidx, node_to_insert);
      return ret;
    } else {
      var node_to_insert = cljs.core.new_path(null, level - 5, tailnode);
      cljs.core.pv_aset(ret, subidx, node_to_insert);
      return ret;
    }
  }
};
cljs.core.vector_index_out_of_bounds = function cljs$core$vector_index_out_of_bounds(
  i,
  cnt
) {
  throw new Error(
    [
      cljs.core.str.cljs$core$IFn$_invoke$arity$1('No item '),
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(i),
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(' in vector of length '),
      cljs.core.str.cljs$core$IFn$_invoke$arity$1(cnt)
    ].join('')
  );
};
cljs.core.first_array_for_longvec = function cljs$core$first_array_for_longvec(
  pv
) {
  var node = pv.root;
  var level = pv.shift;
  while (true) {
    if (level > 0) {
      var G__11237 = cljs.core.pv_aget(node, 0);
      var G__11238 = level - 5;
      node = G__11237;
      level = G__11238;
      continue;
    } else
      return node.arr;
    break;
  }
};
cljs.core.unchecked_array_for = function cljs$core$unchecked_array_for(pv, i) {
  if (i >= cljs.core.tail_off(pv))
    return pv.tail;
  else {
    var node = pv.root;
    var level = pv.shift;
    while (true) {
      if (level > 0) {
        var G__11239 = cljs.core.pv_aget(node, i >>> level & 31);
        var G__11240 = level - 5;
        node = G__11239;
        level = G__11240;
        continue;
      } else
        return node.arr;
      break;
    }
  }
};
cljs.core.array_for = function cljs$core$array_for(pv, i) {
  if (0 <= i && i < pv.cnt) return cljs.core.unchecked_array_for(pv, i);
  else return cljs.core.vector_index_out_of_bounds(i, pv.cnt);
};
cljs.core.do_assoc = function cljs$core$do_assoc(pv, level, node, i, val) {
  var ret = cljs.core.pv_clone_node(node);
  if (level === 0) {
    cljs.core.pv_aset(ret, i & 31, val);
    return ret;
  } else {
    var subidx = i >>> level & 31;
    cljs.core.pv_aset(
      ret,
      subidx,
      (function() {
        var G__11246 = pv;
        var G__11247 = level - 5;
        var G__11248 = cljs.core.pv_aget(node, subidx);
        var G__11249 = i;
        var G__11250 = val;
        return cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5
          ? cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5(
              G__11246,
              G__11247,
              G__11248,
              G__11249,
              G__11250
            )
          : cljs.core.do_assoc.call(
              null,
              G__11246,
              G__11247,
              G__11248,
              G__11249,
              G__11250
            );
      })()
    );
    return ret;
  }
};
cljs.core.pop_tail = function cljs$core$pop_tail(pv, level, node) {
  var subidx = pv.cnt - 2 >>> level & 31;
  if (level > 5) {
    var new_child = (function() {
      var G__11254 = pv;
      var G__11255 = level - 5;
      var G__11256 = cljs.core.pv_aget(node, subidx);
      return cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3
        ? cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3(
            G__11254,
            G__11255,
            G__11256
          )
        : cljs.core.pop_tail.call(null, G__11254, G__11255, G__11256);
    })();
    if (new_child == null && subidx === 0)
      return null;
    else {
      var ret = cljs.core.pv_clone_node(node);
      cljs.core.pv_aset(ret, subidx, new_child);
      return ret;
    }
  } else if (subidx === 0)
    return null;
  else {
    var ret = cljs.core.pv_clone_node(node);
    cljs.core.pv_aset(ret, subidx, null);
    return ret;
  }
};
cljs.core.RangedIterator = function(i, base, arr, v, start, end) {
  this.i = i;
  this.base = base;
  this.arr = arr;
  this.v = v;
  this.start = start;
  this.end = end;
};
cljs.core.RangedIterator.prototype.hasNext = function() {
  var self__ = this;
  var this$ = this;
  return self__.i < self__.end;
};
cljs.core.RangedIterator.prototype.next = function() {
  var self__ = this;
  var this$ = this;
  if (self__.i - self__.base === 32) {
    self__.arr = cljs.core.unchecked_array_for(self__.v, self__.i);
    self__.base = self__.base + 32;
  } else;
  var ret = self__.arr[self__.i & 31];
  self__.i = self__.i + 1;
  return ret;
};
cljs.core.RangedIterator.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    6,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'base', 'base', 1825810849, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'arr', 'arr', 2115492975, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      new cljs.core.Symbol(null, 'v', 'v', 1661996586, null),
      new cljs.core.Symbol(null, 'start', 'start', 1285322546, null),
      new cljs.core.Symbol(null, 'end', 'end', 1372345569, null)
    ],
    null
  );
};
cljs.core.RangedIterator.cljs$lang$type = true;
cljs.core.RangedIterator.cljs$lang$ctorStr = 'cljs.core/RangedIterator';
cljs.core.RangedIterator.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/RangedIterator');
};
cljs.core.__GT_RangedIterator = function cljs$core$__GT_RangedIterator(
  i,
  base,
  arr,
  v,
  start,
  end
) {
  return new cljs.core.RangedIterator(i, base, arr, v, start, end);
};
cljs.core.ranged_iterator = function cljs$core$ranged_iterator(v, start, end) {
  var i = start;
  return new cljs.core.RangedIterator(
    i,
    i - i % 32,
    start < cljs.core.count(v) ? cljs.core.unchecked_array_for(v, i) : null,
    v,
    start,
    end
  );
};
cljs.core.PersistentVector = function(meta, cnt, shift, root, tail, __hash) {
  this.meta = meta;
  this.cnt = cnt;
  this.shift = shift;
  this.root = root;
  this.tail = tail;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 167668511;
  this.cljs$lang$protocol_mask$partition1$ = 8196;
};
cljs.core.PersistentVector.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.PersistentVector.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.PersistentVector.prototype.indexOf = (function() {
  var G__11267 = null;
  var G__11267__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__11267__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11267 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11267__1.call(this, x);
      case 2:
        return G__11267__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11267.cljs$core$IFn$_invoke$arity$1 = G__11267__1;
  G__11267.cljs$core$IFn$_invoke$arity$2 = G__11267__2;
  return G__11267;
})();
cljs.core.PersistentVector.prototype.lastIndexOf = (function() {
  var G__11268 = null;
  var G__11268__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__11268__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11268 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11268__1.call(this, x);
      case 2:
        return G__11268__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11268.cljs$core$IFn$_invoke$arity$1 = G__11268__1;
  G__11268.cljs$core$IFn$_invoke$arity$2 = G__11268__2;
  return G__11268;
})();
cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(
  coll,
  k
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k, null);
};
cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(
  coll,
  k,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (typeof k === 'number')
    return coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
  else
    return not_found;
};
cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(
  v,
  f,
  init
) {
  var self__ = this;
  var v__$1 = this;
  var i = 0;
  var init__$1 = init;
  while (true) {
    if (i < self__.cnt) {
      var arr = cljs.core.unchecked_array_for(v__$1, i);
      var len = arr.length;
      var init__$2 = (function() {
        var j = 0;
        var init__$2 = init__$1;
        while (true) {
          if (j < len) {
            var init__$3 = (function() {
              var G__11258 = init__$2;
              var G__11259 = j + i;
              var G__11260 = arr[j];
              return f.cljs$core$IFn$_invoke$arity$3
                ? f.cljs$core$IFn$_invoke$arity$3(G__11258, G__11259, G__11260)
                : f.call(null, G__11258, G__11259, G__11260);
            })();
            if (cljs.core.reduced_QMARK_(init__$3))
              return init__$3;
            else {
              var G__11269 = j + 1;
              var G__11270 = init__$3;
              j = G__11269;
              init__$2 = G__11270;
              continue;
            }
          } else
            return init__$2;
          break;
        }
      })();
      if (cljs.core.reduced_QMARK_(init__$2))
        return cljs.core.deref.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.deref.cljs$core$IFn$_invoke$arity$1(init__$2)
          : cljs.core.deref.call(null, init__$2);
      else {
        var G__11271 = i + len;
        var G__11272 = init__$2;
        i = G__11271;
        init__$1 = G__11272;
        continue;
      }
    } else
      return init__$1;
    break;
  }
};
cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(
  coll,
  n
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_for(coll__$1, n)[n & 31];
};
cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(
  coll,
  n,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (0 <= n && n < self__.cnt)
    return cljs.core.unchecked_array_for(coll__$1, n)[n & 31];
  else
    return not_found;
};
cljs.core.PersistentVector.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(
  coll,
  n,
  val
) {
  var self__ = this;
  var coll__$1 = this;
  if (0 <= n && n < self__.cnt)
    if (cljs.core.tail_off(coll__$1) <= n) {
      var new_tail = cljs.core.aclone(self__.tail);
      new_tail[n & 31] = val;
      return new cljs.core.PersistentVector(
        self__.meta,
        self__.cnt,
        self__.shift,
        self__.root,
        new_tail,
        null
      );
    } else
      return new cljs.core.PersistentVector(
        self__.meta,
        self__.cnt,
        self__.shift,
        cljs.core.do_assoc(coll__$1, self__.shift, self__.root, n, val),
        self__.tail,
        null
      );
  else if (n === self__.cnt)
    return coll__$1.cljs$core$ICollection$_conj$arity$2(null, val);
  else
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1('Index '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(' out of bounds  [0,'),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(']')
      ].join('')
    );
};
cljs.core.PersistentVector.prototype.cljs$core$IIterable$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.PersistentVector.prototype.cljs$core$IIterable$_iterator$arity$1 = function(
  this$
) {
  var self__ = this;
  var this$__$1 = this;
  return cljs.core.ranged_iterator(this$__$1, 0, self__.cnt);
};
cljs.core.PersistentVector.prototype.cljs$core$IMeta$_meta$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.PersistentVector.prototype.cljs$core$ICloneable$_clone$arity$1 = function(
  _
) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.PersistentVector(
    self__.meta,
    self__.cnt,
    self__.shift,
    self__.root,
    self__.tail,
    self__.__hash
  );
};
cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.cnt;
};
cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_key$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$IIndexed$_nth$arity$2(null, 0);
};
cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_val$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$IIndexed$_nth$arity$2(null, 1);
};
cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.cnt > 0)
    return coll__$1.cljs$core$IIndexed$_nth$arity$2(null, self__.cnt - 1);
  else
    return null;
};
cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.cnt === 0)
    throw new Error("Can't pop empty vector");
  else if (1 === self__.cnt)
    return cljs.core._with_meta(cljs.core.PersistentVector.EMPTY, self__.meta);
  else if (1 < self__.cnt - cljs.core.tail_off(coll__$1))
    return new cljs.core.PersistentVector(
      self__.meta,
      self__.cnt - 1,
      self__.shift,
      self__.root,
      self__.tail.slice(0, -1),
      null
    );
  else {
    var new_tail = cljs.core.unchecked_array_for(coll__$1, self__.cnt - 2);
    var nr = cljs.core.pop_tail(coll__$1, self__.shift, self__.root);
    var new_root = nr == null ? cljs.core.PersistentVector.EMPTY_NODE : nr;
    var cnt_1 = self__.cnt - 1;
    if (5 < self__.shift && cljs.core.pv_aget(new_root, 1) == null)
      return new cljs.core.PersistentVector(
        self__.meta,
        cnt_1,
        self__.shift - 5,
        cljs.core.pv_aget(new_root, 0),
        new_tail,
        null
      );
    else
      return new cljs.core.PersistentVector(
        self__.meta,
        cnt_1,
        self__.shift,
        new_root,
        new_tail,
        null
      );
  }
};
cljs.core.PersistentVector.prototype.cljs$core$IReversible$_rseq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.cnt > 0) return new cljs.core.RSeq(coll__$1, self__.cnt - 1, null);
  else return null;
};
cljs.core.PersistentVector.prototype.cljs$core$IHash$_hash$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  if (other instanceof cljs.core.PersistentVector)
    if (self__.cnt === cljs.core.count(other)) {
      var me_iter = coll__$1.cljs$core$IIterable$_iterator$arity$1(null);
      var you_iter = cljs.core._iterator(other);
      while (true) {
        if (me_iter.hasNext()) {
          var x = me_iter.next();
          var y = you_iter.next();
          if (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x, y)) continue;
          else return false;
        } else
          return true;
        break;
      }
    } else
      return false;
  else
    return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.TransientVector(
    self__.cnt,
    self__.shift,
    cljs.core.tv_editable_root.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.tv_editable_root.cljs$core$IFn$_invoke$arity$1(self__.root)
      : cljs.core.tv_editable_root.call(null, self__.root),
    cljs.core.tv_editable_tail.cljs$core$IFn$_invoke$arity$1
      ? cljs.core.tv_editable_tail.cljs$core$IFn$_invoke$arity$1(self__.tail)
      : cljs.core.tv_editable_tail.call(null, self__.tail)
  );
};
cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.PersistentVector.EMPTY, self__.meta);
};
cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  v,
  f
) {
  var self__ = this;
  var v__$1 = this;
  return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(v__$1, f);
};
cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  v,
  f,
  init
) {
  var self__ = this;
  var v__$1 = this;
  var i = 0;
  var init__$1 = init;
  while (true) {
    if (i < self__.cnt) {
      var arr = cljs.core.unchecked_array_for(v__$1, i);
      var len = arr.length;
      var init__$2 = (function() {
        var j = 0;
        var init__$2 = init__$1;
        while (true) {
          if (j < len) {
            var init__$3 = (function() {
              var G__11261 = init__$2;
              var G__11262 = arr[j];
              return f.cljs$core$IFn$_invoke$arity$2
                ? f.cljs$core$IFn$_invoke$arity$2(G__11261, G__11262)
                : f.call(null, G__11261, G__11262);
            })();
            if (cljs.core.reduced_QMARK_(init__$3))
              return init__$3;
            else {
              var G__11273 = j + 1;
              var G__11274 = init__$3;
              j = G__11273;
              init__$2 = G__11274;
              continue;
            }
          } else
            return init__$2;
          break;
        }
      })();
      if (cljs.core.reduced_QMARK_(init__$2))
        return cljs.core.deref.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.deref.cljs$core$IFn$_invoke$arity$1(init__$2)
          : cljs.core.deref.call(null, init__$2);
      else {
        var G__11275 = i + len;
        var G__11276 = init__$2;
        i = G__11275;
        init__$1 = G__11276;
        continue;
      }
    } else
      return init__$1;
    break;
  }
};
cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(
  coll,
  k,
  v
) {
  var self__ = this;
  var coll__$1 = this;
  if (typeof k === 'number')
    return coll__$1.cljs$core$IVector$_assoc_n$arity$3(null, k, v);
  else
    throw new Error("Vector's key for assoc must be a number.");
};
cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.cnt === 0)
    return null;
  else if (self__.cnt <= 32)
    return new cljs.core.IndexedSeq(self__.tail, 0, null);
  else {
    var G__11263 = coll__$1;
    var G__11264 = cljs.core.first_array_for_longvec(coll__$1);
    var G__11265 = 0;
    var G__11266 = 0;
    return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4
      ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
          G__11263,
          G__11264,
          G__11265,
          G__11266
        )
      : cljs.core.chunked_seq.call(
          null,
          G__11263,
          G__11264,
          G__11265,
          G__11266
        );
  }
};
cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.PersistentVector(
    meta__$1,
    self__.cnt,
    self__.shift,
    self__.root,
    self__.tail,
    self__.__hash
  );
};
cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.cnt - cljs.core.tail_off(coll__$1) < 32) {
    var len = self__.tail.length;
    var new_tail = new Array(len + 1);
    var n__8067__auto___11277 = len;
    var i_11278 = 0;
    while (true) {
      if (i_11278 < n__8067__auto___11277) {
        new_tail[i_11278] = self__.tail[i_11278];
        var G__11279 = i_11278 + 1;
        i_11278 = G__11279;
        continue;
      } else;
      break;
    }
    new_tail[len] = o;
    return new cljs.core.PersistentVector(
      self__.meta,
      self__.cnt + 1,
      self__.shift,
      self__.root,
      new_tail,
      null
    );
  } else {
    var root_overflow_QMARK_ = self__.cnt >>> 5 > 1 << self__.shift;
    var new_shift = root_overflow_QMARK_ ? self__.shift + 5 : self__.shift;
    var new_root = root_overflow_QMARK_
      ? (function() {
          var n_r = cljs.core.pv_fresh_node(null);
          cljs.core.pv_aset(n_r, 0, self__.root);
          cljs.core.pv_aset(
            n_r,
            1,
            cljs.core.new_path(
              null,
              self__.shift,
              new cljs.core.VectorNode(null, self__.tail)
            )
          );
          return n_r;
        })()
      : cljs.core.push_tail(
          coll__$1,
          self__.shift,
          self__.root,
          new cljs.core.VectorNode(null, self__.tail)
        );
    return new cljs.core.PersistentVector(
      self__.meta,
      self__.cnt + 1,
      new_shift,
      new_root,
      [o],
      null
    );
  }
};
cljs.core.PersistentVector.prototype.call = (function() {
  var G__11280 = null;
  var G__11280__2 = function(self__, k) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
  };
  var G__11280__3 = function(self__, k, not_found) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
  };
  G__11280 = function(self__, k, not_found) {
    switch (arguments.length) {
      case 2:
        return G__11280__2.call(this, self__, k);
      case 3:
        return G__11280__3.call(this, self__, k, not_found);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11280.cljs$core$IFn$_invoke$arity$2 = G__11280__2;
  G__11280.cljs$core$IFn$_invoke$arity$3 = G__11280__3;
  return G__11280;
})();
cljs.core.PersistentVector.prototype.apply = function(self__, args11257) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args11257))
  );
};
cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(
  k
) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
};
cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(
  k,
  not_found
) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
};
cljs.core.PersistentVector.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    6,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'cnt', 'cnt', 1924510325, null),
      new cljs.core.Symbol(null, 'shift', 'shift', -1657295705, null),
      new cljs.core.Symbol(null, 'root', 'root', 1191874074, null),
      new cljs.core.Symbol(null, 'tail', 'tail', 494507963, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.PersistentVector.cljs$lang$type = true;
cljs.core.PersistentVector.cljs$lang$ctorStr = 'cljs.core/PersistentVector';
cljs.core.PersistentVector.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/PersistentVector');
};
cljs.core.__GT_PersistentVector = function cljs$core$__GT_PersistentVector(
  meta,
  cnt,
  shift,
  root,
  tail,
  __hash
) {
  return new cljs.core.PersistentVector(meta, cnt, shift, root, tail, __hash);
};
cljs.core.PersistentVector.EMPTY_NODE = new cljs.core.VectorNode(null, [
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null,
  null
]);
cljs.core.PersistentVector.EMPTY = new cljs.core.PersistentVector(
  null,
  0,
  5,
  cljs.core.PersistentVector.EMPTY_NODE,
  [],
  cljs.core.empty_ordered_hash
);
cljs.core.PersistentVector.fromArray = function(xs, no_clone) {
  var l = xs.length;
  var xs__$1 = no_clone ? xs : cljs.core.aclone(xs);
  if (l < 32)
    return new cljs.core.PersistentVector(
      null,
      l,
      5,
      cljs.core.PersistentVector.EMPTY_NODE,
      xs__$1,
      null
    );
  else {
    var node = xs__$1.slice(0, 32);
    var v = new cljs.core.PersistentVector(
      null,
      32,
      5,
      cljs.core.PersistentVector.EMPTY_NODE,
      node,
      null
    );
    var i = 32;
    var out = v.cljs$core$IEditableCollection$_as_transient$arity$1(null);
    while (true) {
      if (i < l) {
        var G__11281 = i + 1;
        var G__11282 = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(
          out,
          xs__$1[i]
        );
        i = G__11281;
        out = G__11282;
        continue;
      } else
        return cljs.core.persistent_BANG_(out);
      break;
    }
  }
};
cljs.core.PersistentVector.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.vec = function cljs$core$vec(coll) {
  if (cljs.core.array_QMARK_(coll))
    return cljs.core.PersistentVector.fromArray(coll, true);
  else
    return cljs.core._persistent_BANG_(
      cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(
        cljs.core._conj_BANG_,
        cljs.core._as_transient(cljs.core.PersistentVector.EMPTY),
        coll
      )
    );
};
cljs.core.vector = function cljs$core$vector(var_args) {
  var args__8264__auto__ = [];
  var len__8257__auto___11284 = arguments.length;
  var i__8258__auto___11285 = 0;
  while (true) {
    if (i__8258__auto___11285 < len__8257__auto___11284) {
      args__8264__auto__.push(arguments[i__8258__auto___11285]);
      var G__11286 = i__8258__auto___11285 + 1;
      i__8258__auto___11285 = G__11286;
      continue;
    } else;
    break;
  }
  var argseq__8265__auto__ = 0 < args__8264__auto__.length
    ? new cljs.core.IndexedSeq(args__8264__auto__.slice(0), 0, null)
    : null;
  return cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic(
    argseq__8265__auto__
  );
};
cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic = function(args) {
  if (args instanceof cljs.core.IndexedSeq && args.i === 0)
    return cljs.core.PersistentVector.fromArray(args.arr, true);
  else
    return cljs.core.vec(args);
};
cljs.core.vector.cljs$lang$maxFixedArity = 0;
cljs.core.vector.cljs$lang$applyTo = function(seq11283) {
  return cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic(
    cljs.core.seq(seq11283)
  );
};
cljs.core.ChunkedSeq = function(vec, node, i, off, meta, __hash) {
  this.vec = vec;
  this.node = node;
  this.i = i;
  this.off = off;
  this.meta = meta;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 32375020;
  this.cljs$lang$protocol_mask$partition1$ = 1536;
};
cljs.core.ChunkedSeq.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.ChunkedSeq.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.ChunkedSeq.prototype.indexOf = (function() {
  var G__11309 = null;
  var G__11309__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__11309__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11309 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11309__1.call(this, x);
      case 2:
        return G__11309__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11309.cljs$core$IFn$_invoke$arity$1 = G__11309__1;
  G__11309.cljs$core$IFn$_invoke$arity$2 = G__11309__2;
  return G__11309;
})();
cljs.core.ChunkedSeq.prototype.lastIndexOf = (function() {
  var G__11310 = null;
  var G__11310__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__11310__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11310 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11310__1.call(this, x);
      case 2:
        return G__11310__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11310.cljs$core$IFn$_invoke$arity$1 = G__11310__1;
  G__11310.cljs$core$IFn$_invoke$arity$2 = G__11310__2;
  return G__11310;
})();
cljs.core.ChunkedSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.off + 1 < self__.node.length) {
    var s = (function() {
      var G__11287 = self__.vec;
      var G__11288 = self__.node;
      var G__11289 = self__.i;
      var G__11290 = self__.off + 1;
      return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4
        ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
            G__11287,
            G__11288,
            G__11289,
            G__11290
          )
        : cljs.core.chunked_seq.call(
            null,
            G__11287,
            G__11288,
            G__11289,
            G__11290
          );
    })();
    if (s == null) return null;
    else return s;
  } else
    return coll__$1.cljs$core$IChunkedNext$_chunked_next$arity$1(null);
};
cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.ChunkedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.PersistentVector.EMPTY, self__.meta);
};
cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(
    (function() {
      var G__11291 = self__.vec;
      var G__11292 = self__.i + self__.off;
      var G__11293 = cljs.core.count(self__.vec);
      return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3
        ? cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(
            G__11291,
            G__11292,
            G__11293
          )
        : cljs.core.subvec.call(null, G__11291, G__11292, G__11293);
    })(),
    f
  );
};
cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(
    (function() {
      var G__11294 = self__.vec;
      var G__11295 = self__.i + self__.off;
      var G__11296 = cljs.core.count(self__.vec);
      return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3
        ? cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(
            G__11294,
            G__11295,
            G__11296
          )
        : cljs.core.subvec.call(null, G__11294, G__11295, G__11296);
    })(),
    f,
    start
  );
};
cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.node[self__.off];
};
cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.off + 1 < self__.node.length) {
    var s = (function() {
      var G__11297 = self__.vec;
      var G__11298 = self__.node;
      var G__11299 = self__.i;
      var G__11300 = self__.off + 1;
      return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4
        ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
            G__11297,
            G__11298,
            G__11299,
            G__11300
          )
        : cljs.core.chunked_seq.call(
            null,
            G__11297,
            G__11298,
            G__11299,
            G__11300
          );
    })();
    if (s == null) return cljs.core.List.EMPTY;
    else return s;
  } else
    return coll__$1.cljs$core$IChunkedSeq$_chunked_rest$arity$1(null);
};
cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2(
    self__.node,
    self__.off
  );
};
cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var end = self__.i + self__.node.length;
  if (end < cljs.core._count(self__.vec)) {
    var G__11301 = self__.vec;
    var G__11302 = cljs.core.unchecked_array_for(self__.vec, end);
    var G__11303 = end;
    var G__11304 = 0;
    return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4
      ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
          G__11301,
          G__11302,
          G__11303,
          G__11304
        )
      : cljs.core.chunked_seq.call(
          null,
          G__11301,
          G__11302,
          G__11303,
          G__11304
        );
  } else
    return cljs.core.List.EMPTY;
};
cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  m
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5
    ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5(
        self__.vec,
        self__.node,
        self__.i,
        self__.off,
        m
      )
    : cljs.core.chunked_seq.call(
        null,
        self__.vec,
        self__.node,
        self__.i,
        self__.off,
        m
      );
};
cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.cons(o, coll__$1);
};
cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var end = self__.i + self__.node.length;
  if (end < cljs.core._count(self__.vec)) {
    var G__11305 = self__.vec;
    var G__11306 = cljs.core.unchecked_array_for(self__.vec, end);
    var G__11307 = end;
    var G__11308 = 0;
    return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4
      ? cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
          G__11305,
          G__11306,
          G__11307,
          G__11308
        )
      : cljs.core.chunked_seq.call(
          null,
          G__11305,
          G__11306,
          G__11307,
          G__11308
        );
  } else
    return null;
};
cljs.core.ChunkedSeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    6,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'vec', 'vec', 982683596, null),
      new cljs.core.Symbol(null, 'node', 'node', -2073234571, null),
      new cljs.core.Symbol(null, 'i', 'i', 253690212, null),
      new cljs.core.Symbol(null, 'off', 'off', -2047994980, null),
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.ChunkedSeq.cljs$lang$type = true;
cljs.core.ChunkedSeq.cljs$lang$ctorStr = 'cljs.core/ChunkedSeq';
cljs.core.ChunkedSeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/ChunkedSeq');
};
cljs.core.__GT_ChunkedSeq = function cljs$core$__GT_ChunkedSeq(
  vec,
  node,
  i,
  off,
  meta,
  __hash
) {
  return new cljs.core.ChunkedSeq(vec, node, i, off, meta, __hash);
};
cljs.core.ChunkedSeq.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.chunked_seq = function cljs$core$chunked_seq(var_args) {
  var args11311 = [];
  var len__8257__auto___11314 = arguments.length;
  var i__8258__auto___11315 = 0;
  while (true) {
    if (i__8258__auto___11315 < len__8257__auto___11314) {
      args11311.push(arguments[i__8258__auto___11315]);
      var G__11316 = i__8258__auto___11315 + 1;
      i__8258__auto___11315 = G__11316;
      continue;
    } else;
    break;
  }
  var G__11313 = args11311.length;
  switch (G__11313) {
    case 3:
      return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    case 4:
      return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3]
      );
      break;
    case 5:
      return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5(
        arguments[0],
        arguments[1],
        arguments[2],
        arguments[3],
        arguments[4]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11311.length)
        ].join('')
      );
  }
};
cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3 = function(vec, i, off) {
  return new cljs.core.ChunkedSeq(
    vec,
    cljs.core.array_for(vec, i),
    i,
    off,
    null,
    null
  );
};
cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 = function(
  vec,
  node,
  i,
  off
) {
  return new cljs.core.ChunkedSeq(vec, node, i, off, null, null);
};
cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5 = function(
  vec,
  node,
  i,
  off,
  meta
) {
  return new cljs.core.ChunkedSeq(vec, node, i, off, meta, null);
};
cljs.core.chunked_seq.cljs$lang$maxFixedArity = 5;
cljs.core.Subvec = function(meta, v, start, end, __hash) {
  this.meta = meta;
  this.v = v;
  this.start = start;
  this.end = end;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 167666463;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.Subvec.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.Subvec.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.Subvec.prototype.indexOf = (function() {
  var G__11338 = null;
  var G__11338__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__11338__2 = function(x, start__$1) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start__$1);
  };
  G__11338 = function(x, start__$1) {
    switch (arguments.length) {
      case 1:
        return G__11338__1.call(this, x);
      case 2:
        return G__11338__2.call(this, x, start__$1);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11338.cljs$core$IFn$_invoke$arity$1 = G__11338__1;
  G__11338.cljs$core$IFn$_invoke$arity$2 = G__11338__2;
  return G__11338;
})();
cljs.core.Subvec.prototype.lastIndexOf = (function() {
  var G__11339 = null;
  var G__11339__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__11339__2 = function(x, start__$1) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      start__$1
    );
  };
  G__11339 = function(x, start__$1) {
    switch (arguments.length) {
      case 1:
        return G__11339__1.call(this, x);
      case 2:
        return G__11339__2.call(this, x, start__$1);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11339.cljs$core$IFn$_invoke$arity$1 = G__11339__1;
  G__11339.cljs$core$IFn$_invoke$arity$2 = G__11339__2;
  return G__11339;
})();
cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 = function(
  coll,
  k
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k, null);
};
cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 = function(
  coll,
  k,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (typeof k === 'number')
    return coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
  else
    return not_found;
};
cljs.core.Subvec.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(
  coll,
  f,
  init
) {
  var self__ = this;
  var coll__$1 = this;
  var i = self__.start;
  var j = 0;
  var init__$1 = init;
  while (true) {
    if (i < self__.end) {
      var init__$2 = (function() {
        var G__11319 = init__$1;
        var G__11320 = j;
        var G__11321 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
          self__.v,
          i
        );
        return f.cljs$core$IFn$_invoke$arity$3
          ? f.cljs$core$IFn$_invoke$arity$3(G__11319, G__11320, G__11321)
          : f.call(null, G__11319, G__11320, G__11321);
      })();
      if (cljs.core.reduced_QMARK_(init__$2))
        return cljs.core.deref.cljs$core$IFn$_invoke$arity$1
          ? cljs.core.deref.cljs$core$IFn$_invoke$arity$1(init__$2)
          : cljs.core.deref.call(null, init__$2);
      else {
        var G__11340 = i + 1;
        var G__11341 = j + 1;
        var G__11342 = init__$2;
        i = G__11340;
        j = G__11341;
        init__$1 = G__11342;
        continue;
      }
    } else
      return init__$1;
    break;
  }
};
cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
  var self__ = this;
  var coll__$1 = this;
  if (n < 0 || self__.end <= self__.start + n)
    return cljs.core.vector_index_out_of_bounds(n, self__.end - self__.start);
  else
    return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(
      self__.v,
      self__.start + n
    );
};
cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$3 = function(
  coll,
  n,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (n < 0 || self__.end <= self__.start + n) return not_found;
  else return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(
      self__.v,
      self__.start + n,
      not_found
    );
};
cljs.core.Subvec.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(
  coll,
  n,
  val
) {
  var self__ = this;
  var coll__$1 = this;
  var v_pos = self__.start + n;
  if (n < 0 || self__.end + 1 <= v_pos)
    throw new Error(
      [
        cljs.core.str.cljs$core$IFn$_invoke$arity$1('Index '),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(' out of bounds [0,'),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(
          coll__$1.cljs$core$ICounted$_count$arity$1(null)
        ),
        cljs.core.str.cljs$core$IFn$_invoke$arity$1(']')
      ].join('')
    );
  else {
    var G__11322 = self__.meta;
    var G__11323 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(
      self__.v,
      v_pos,
      val
    );
    var G__11324 = self__.start;
    var G__11325 = (function() {
      var x__7480__auto__ = self__.end;
      var y__7481__auto__ = v_pos + 1;
      return x__7480__auto__ > y__7481__auto__
        ? x__7480__auto__
        : y__7481__auto__;
    })();
    var G__11326 = null;
    return cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5
      ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(
          G__11322,
          G__11323,
          G__11324,
          G__11325,
          G__11326
        )
      : cljs.core.build_subvec.call(
          null,
          G__11322,
          G__11323,
          G__11324,
          G__11325,
          G__11326
        );
  }
};
cljs.core.Subvec.prototype.cljs$core$IIterable$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.Subvec.prototype.cljs$core$IIterable$_iterator$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.ranged_iterator(self__.v, self__.start, self__.end);
};
cljs.core.Subvec.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.Subvec.prototype.cljs$core$ICloneable$_clone$arity$1 = function(_) {
  var self__ = this;
  var ___$1 = this;
  return new cljs.core.Subvec(
    self__.meta,
    self__.v,
    self__.start,
    self__.end,
    self__.__hash
  );
};
cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return self__.end - self__.start;
};
cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v, self__.end - 1);
};
cljs.core.Subvec.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.start === self__.end)
    throw new Error("Can't pop empty vector");
  else {
    var G__11327 = self__.meta;
    var G__11328 = self__.v;
    var G__11329 = self__.start;
    var G__11330 = self__.end - 1;
    var G__11331 = null;
    return cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5
      ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(
          G__11327,
          G__11328,
          G__11329,
          G__11330,
          G__11331
        )
      : cljs.core.build_subvec.call(
          null,
          G__11327,
          G__11328,
          G__11329,
          G__11330,
          G__11331
        );
  }
};
cljs.core.Subvec.prototype.cljs$core$IReversible$_rseq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (!(self__.start === self__.end))
    return new cljs.core.RSeq(coll__$1, self__.end - self__.start - 1, null);
  else
    return null;
};
cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.Subvec.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.PersistentVector.EMPTY, self__.meta);
};
cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$2 = function(
  coll,
  f
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(coll__$1, f);
};
cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 = function(
  coll,
  f,
  start__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(
    coll__$1,
    f,
    start__$1
  );
};
cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(
  coll,
  key,
  val
) {
  var self__ = this;
  var coll__$1 = this;
  if (typeof key === 'number')
    return coll__$1.cljs$core$IVector$_assoc_n$arity$3(null, key, val);
  else
    throw new Error("Subvec's key for assoc must be a number.");
};
cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
  var self__ = this;
  var coll__$1 = this;
  var subvec_seq = (function(coll__$1) {
    return function cljs$core$subvec_seq(i) {
      if (i === self__.end)
        return null;
      else
        return cljs.core.cons(
          cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v, i),
          new cljs.core.LazySeq(
            null,
            (function(coll__$1) {
              return function() {
                return cljs$core$subvec_seq(i + 1);
              };
            })(coll__$1),
            null,
            null
          )
        );
    };
  })(coll__$1);
  return subvec_seq(self__.start);
};
cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5
    ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(
        meta__$1,
        self__.v,
        self__.start,
        self__.end,
        self__.__hash
      )
    : cljs.core.build_subvec.call(
        null,
        meta__$1,
        self__.v,
        self__.start,
        self__.end,
        self__.__hash
      );
};
cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  var G__11333 = self__.meta;
  var G__11334 = cljs.core._assoc_n(self__.v, self__.end, o);
  var G__11335 = self__.start;
  var G__11336 = self__.end + 1;
  var G__11337 = null;
  return cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5
    ? cljs.core.build_subvec.cljs$core$IFn$_invoke$arity$5(
        G__11333,
        G__11334,
        G__11335,
        G__11336,
        G__11337
      )
    : cljs.core.build_subvec.call(
        null,
        G__11333,
        G__11334,
        G__11335,
        G__11336,
        G__11337
      );
};
cljs.core.Subvec.prototype.call = (function() {
  var G__11343 = null;
  var G__11343__2 = function(self__, k) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
  };
  var G__11343__3 = function(self__, k, not_found) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
  };
  G__11343 = function(self__, k, not_found) {
    switch (arguments.length) {
      case 2:
        return G__11343__2.call(this, self__, k);
      case 3:
        return G__11343__3.call(this, self__, k, not_found);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11343.cljs$core$IFn$_invoke$arity$2 = G__11343__2;
  G__11343.cljs$core$IFn$_invoke$arity$3 = G__11343__3;
  return G__11343;
})();
cljs.core.Subvec.prototype.apply = function(self__, args11318) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args11318))
  );
};
cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
};
cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$2 = function(
  k,
  not_found
) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
};
cljs.core.Subvec.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    5,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'v', 'v', 1661996586, null),
      new cljs.core.Symbol(null, 'start', 'start', 1285322546, null),
      new cljs.core.Symbol(null, 'end', 'end', 1372345569, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.Subvec.cljs$lang$type = true;
cljs.core.Subvec.cljs$lang$ctorStr = 'cljs.core/Subvec';
cljs.core.Subvec.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/Subvec');
};
cljs.core.__GT_Subvec = function cljs$core$__GT_Subvec(
  meta,
  v,
  start,
  end,
  __hash
) {
  return new cljs.core.Subvec(meta, v, start, end, __hash);
};
cljs.core.Subvec.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.build_subvec = function cljs$core$build_subvec(
  meta,
  v,
  start,
  end,
  __hash
) {
  while (true) {
    if (v instanceof cljs.core.Subvec) {
      var G__11344 = meta;
      var G__11345 = v.v;
      var G__11346 = v.start + start;
      var G__11347 = v.start + end;
      var G__11348 = __hash;
      meta = G__11344;
      v = G__11345;
      start = G__11346;
      end = G__11347;
      __hash = G__11348;
      continue;
    } else {
      var c = cljs.core.count(v);
      if (start < 0 || end < 0 || start > c || end > c)
        throw new Error('Index out of bounds');
      else;
      return new cljs.core.Subvec(meta, v, start, end, __hash);
    }
    break;
  }
};
cljs.core.subvec = function cljs$core$subvec(var_args) {
  var args11349 = [];
  var len__8257__auto___11352 = arguments.length;
  var i__8258__auto___11353 = 0;
  while (true) {
    if (i__8258__auto___11353 < len__8257__auto___11352) {
      args11349.push(arguments[i__8258__auto___11353]);
      var G__11354 = i__8258__auto___11353 + 1;
      i__8258__auto___11353 = G__11354;
      continue;
    } else;
    break;
  }
  var G__11351 = args11349.length;
  switch (G__11351) {
    case 2:
      return cljs.core.subvec.cljs$core$IFn$_invoke$arity$2(
        arguments[0],
        arguments[1]
      );
      break;
    case 3:
      return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(
        arguments[0],
        arguments[1],
        arguments[2]
      );
      break;
    default:
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Invalid arity: '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(args11349.length)
        ].join('')
      );
  }
};
cljs.core.subvec.cljs$core$IFn$_invoke$arity$2 = function(v, start) {
  return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(
    v,
    start,
    cljs.core.count(v)
  );
};
cljs.core.subvec.cljs$core$IFn$_invoke$arity$3 = function(v, start, end) {
  return cljs.core.build_subvec(null, v, start, end, null);
};
cljs.core.subvec.cljs$lang$maxFixedArity = 3;
cljs.core.tv_ensure_editable = function cljs$core$tv_ensure_editable(
  edit,
  node
) {
  if (edit === node.edit) return node;
  else return new cljs.core.VectorNode(edit, cljs.core.aclone(node.arr));
};
cljs.core.tv_editable_root = function cljs$core$tv_editable_root(node) {
  return new cljs.core.VectorNode({}, cljs.core.aclone(node.arr));
};
cljs.core.tv_editable_tail = function cljs$core$tv_editable_tail(tl) {
  var ret = [
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    null
  ];
  cljs.core.array_copy(tl, 0, ret, 0, tl.length);
  return ret;
};
cljs.core.tv_push_tail = function cljs$core$tv_push_tail(
  tv,
  level,
  parent,
  tail_node
) {
  var ret = cljs.core.tv_ensure_editable(tv.root.edit, parent);
  var subidx = tv.cnt - 1 >>> level & 31;
  cljs.core.pv_aset(
    ret,
    subidx,
    level === 5
      ? tail_node
      : (function() {
          var child = cljs.core.pv_aget(ret, subidx);
          if (!(child == null)) {
            var G__11364 = tv;
            var G__11365 = level - 5;
            var G__11366 = child;
            var G__11367 = tail_node;
            return cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4
              ? cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4(
                  G__11364,
                  G__11365,
                  G__11366,
                  G__11367
                )
              : cljs.core.tv_push_tail.call(
                  null,
                  G__11364,
                  G__11365,
                  G__11366,
                  G__11367
                );
          } else
            return cljs.core.new_path(tv.root.edit, level - 5, tail_node);
        })()
  );
  return ret;
};
cljs.core.tv_pop_tail = function cljs$core$tv_pop_tail(tv, level, node) {
  var node__$1 = cljs.core.tv_ensure_editable(tv.root.edit, node);
  var subidx = tv.cnt - 2 >>> level & 31;
  if (level > 5) {
    var new_child = (function() {
      var G__11371 = tv;
      var G__11372 = level - 5;
      var G__11373 = cljs.core.pv_aget(node__$1, subidx);
      return cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3
        ? cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3(
            G__11371,
            G__11372,
            G__11373
          )
        : cljs.core.tv_pop_tail.call(null, G__11371, G__11372, G__11373);
    })();
    if (new_child == null && subidx === 0)
      return null;
    else {
      cljs.core.pv_aset(node__$1, subidx, new_child);
      return node__$1;
    }
  } else if (subidx === 0)
    return null;
  else {
    cljs.core.pv_aset(node__$1, subidx, null);
    return node__$1;
  }
};
cljs.core.unchecked_editable_array_for = function cljs$core$unchecked_editable_array_for(
  tv,
  i
) {
  if (i >= cljs.core.tail_off(tv))
    return tv.tail;
  else {
    var root = tv.root;
    var node = root;
    var level = tv.shift;
    while (true) {
      if (level > 0) {
        var G__11374 = cljs.core.tv_ensure_editable(
          root.edit,
          cljs.core.pv_aget(node, i >>> level & 31)
        );
        var G__11375 = level - 5;
        node = G__11374;
        level = G__11375;
        continue;
      } else
        return node.arr;
      break;
    }
  }
};
cljs.core.TransientVector = function(cnt, shift, root, tail) {
  this.cnt = cnt;
  this.shift = shift;
  this.root = root;
  this.tail = tail;
  this.cljs$lang$protocol_mask$partition1$ = 88;
  this.cljs$lang$protocol_mask$partition0$ = 275;
};
cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(
  tcoll,
  o
) {
  var self__ = this;
  var tcoll__$1 = this;
  if (self__.root.edit)
    if (self__.cnt - cljs.core.tail_off(tcoll__$1) < 32) {
      self__.tail[self__.cnt & 31] = o;
      self__.cnt = self__.cnt + 1;
      return tcoll__$1;
    } else {
      var tail_node = new cljs.core.VectorNode(self__.root.edit, self__.tail);
      var new_tail = [
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null,
        null
      ];
      new_tail[0] = o;
      self__.tail = new_tail;
      if (self__.cnt >>> 5 > 1 << self__.shift) {
        var new_root_array = [
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null,
          null
        ];
        var new_shift = self__.shift + 5;
        new_root_array[0] = self__.root;
        new_root_array[1] = cljs.core.new_path(
          self__.root.edit,
          self__.shift,
          tail_node
        );
        self__.root = new cljs.core.VectorNode(
          self__.root.edit,
          new_root_array
        );
        self__.shift = new_shift;
        self__.cnt = self__.cnt + 1;
        return tcoll__$1;
      } else {
        var new_root = cljs.core.tv_push_tail(
          tcoll__$1,
          self__.shift,
          self__.root,
          tail_node
        );
        self__.root = new_root;
        self__.cnt = self__.cnt + 1;
        return tcoll__$1;
      }
    }
  else
    throw new Error('conj! after persistent!');
};
cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(
  tcoll
) {
  var self__ = this;
  var tcoll__$1 = this;
  if (self__.root.edit) {
    self__.root.edit = null;
    var len = self__.cnt - cljs.core.tail_off(tcoll__$1);
    var trimmed_tail = new Array(len);
    cljs.core.array_copy(self__.tail, 0, trimmed_tail, 0, len);
    return new cljs.core.PersistentVector(
      null,
      self__.cnt,
      self__.shift,
      self__.root,
      trimmed_tail,
      null
    );
  } else
    throw new Error('persistent! called twice');
};
cljs.core.TransientVector.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(
  tcoll,
  key,
  val
) {
  var self__ = this;
  var tcoll__$1 = this;
  if (typeof key === 'number')
    return tcoll__$1.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(
      null,
      key,
      val
    );
  else
    throw new Error("TransientVector's key for assoc! must be a number.");
};
cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 = function(
  tcoll,
  n,
  val
) {
  var self__ = this;
  var tcoll__$1 = this;
  if (self__.root.edit)
    if (0 <= n && n < self__.cnt)
      if (cljs.core.tail_off(tcoll__$1) <= n) {
        self__.tail[n & 31] = val;
        return tcoll__$1;
      } else {
        var new_root = (function(tcoll__$1) {
          return function cljs$core$go(level, node) {
            var node__$1 = cljs.core.tv_ensure_editable(self__.root.edit, node);
            if (level === 0) {
              cljs.core.pv_aset(node__$1, n & 31, val);
              return node__$1;
            } else {
              var subidx = n >>> level & 31;
              cljs.core.pv_aset(
                node__$1,
                subidx,
                cljs$core$go(level - 5, cljs.core.pv_aget(node__$1, subidx))
              );
              return node__$1;
            }
          };
        })(tcoll__$1).call(null, self__.shift, self__.root);
        self__.root = new_root;
        return tcoll__$1;
      }
    else if (n === self__.cnt)
      return tcoll__$1.cljs$core$ITransientCollection$_conj_BANG_$arity$2(
        null,
        val
      );
    else
      throw new Error(
        [
          cljs.core.str.cljs$core$IFn$_invoke$arity$1('Index '),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(n),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(
            ' out of bounds for TransientVector of length'
          ),
          cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt)
        ].join('')
      );
  else
    throw new Error('assoc! after persistent!');
};
cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_pop_BANG_$arity$1 = function(
  tcoll
) {
  var self__ = this;
  var tcoll__$1 = this;
  if (self__.root.edit)
    if (self__.cnt === 0)
      throw new Error("Can't pop empty vector");
    else if (1 === self__.cnt) {
      self__.cnt = 0;
      return tcoll__$1;
    } else if ((self__.cnt - 1 & 31) > 0) {
      self__.cnt = self__.cnt - 1;
      return tcoll__$1;
    } else {
      var new_tail = cljs.core.unchecked_editable_array_for(
        tcoll__$1,
        self__.cnt - 2
      );
      var new_root = (function() {
        var nr = cljs.core.tv_pop_tail(tcoll__$1, self__.shift, self__.root);
        if (!(nr == null)) return nr;
        else return new cljs.core.VectorNode(self__.root.edit, [
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            null
          ]);
      })();
      if (5 < self__.shift && cljs.core.pv_aget(new_root, 1) == null) {
        var new_root__$1 = cljs.core.tv_ensure_editable(
          self__.root.edit,
          cljs.core.pv_aget(new_root, 0)
        );
        self__.root = new_root__$1;
        self__.shift = self__.shift - 5;
        self__.cnt = self__.cnt - 1;
        self__.tail = new_tail;
        return tcoll__$1;
      } else {
        self__.root = new_root;
        self__.cnt = self__.cnt - 1;
        self__.tail = new_tail;
        return tcoll__$1;
      }
    }
  else
    throw new Error('pop! after persistent!');
};
cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.root.edit) return self__.cnt;
  else throw new Error('count after persistent!');
};
cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(
  coll,
  n
) {
  var self__ = this;
  var coll__$1 = this;
  if (self__.root.edit) return cljs.core.array_for(coll__$1, n)[n & 31];
  else throw new Error('nth after persistent!');
};
cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(
  coll,
  n,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (0 <= n && n < self__.cnt)
    return coll__$1.cljs$core$IIndexed$_nth$arity$2(null, n);
  else
    return not_found;
};
cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(
  coll,
  k
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k, null);
};
cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(
  coll,
  k,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (typeof k === 'number')
    return coll__$1.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
  else
    return not_found;
};
cljs.core.TransientVector.prototype.call = (function() {
  var G__11379 = null;
  var G__11379__2 = function(self__, k) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
  };
  var G__11379__3 = function(self__, k, not_found) {
    var self__ = this;
    var self____$1 = this;
    var coll = self____$1;
    return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
  };
  G__11379 = function(self__, k, not_found) {
    switch (arguments.length) {
      case 2:
        return G__11379__2.call(this, self__, k);
      case 3:
        return G__11379__3.call(this, self__, k, not_found);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11379.cljs$core$IFn$_invoke$arity$2 = G__11379__2;
  G__11379.cljs$core$IFn$_invoke$arity$3 = G__11379__3;
  return G__11379;
})();
cljs.core.TransientVector.prototype.apply = function(self__, args11376) {
  var self__ = this;
  var self____$1 = this;
  return self____$1.call.apply(
    self____$1,
    [self____$1].concat(cljs.core.aclone(args11376))
  );
};
cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(
  k
) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
};
cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(
  k,
  not_found
) {
  var self__ = this;
  var coll = this;
  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
};
cljs.core.TransientVector.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'cnt', 'cnt', 1924510325, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'shift', 'shift', -1657295705, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'root', 'root', 1191874074, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'tail', 'tail', 494507963, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.TransientVector.cljs$lang$type = true;
cljs.core.TransientVector.cljs$lang$ctorStr = 'cljs.core/TransientVector';
cljs.core.TransientVector.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/TransientVector');
};
cljs.core.__GT_TransientVector = function cljs$core$__GT_TransientVector(
  cnt,
  shift,
  root,
  tail
) {
  return new cljs.core.TransientVector(cnt, shift, root, tail);
};
cljs.core.PersistentQueueIter = function(fseq, riter) {
  this.fseq = fseq;
  this.riter = riter;
};
cljs.core.PersistentQueueIter.prototype.hasNext = function() {
  var self__ = this;
  var _ = this;
  var or__7144__auto__ = !(self__.fseq == null) && cljs.core.seq(self__.fseq);
  if (or__7144__auto__)
    return or__7144__auto__;
  else {
    var and__7132__auto__ = !(self__.riter == null);
    if (and__7132__auto__) return self__.riter.hasNext();
    else return and__7132__auto__;
  }
};
cljs.core.PersistentQueueIter.prototype.next = function() {
  var self__ = this;
  var _ = this;
  if (!(self__.fseq == null)) {
    var ret = cljs.core.first(self__.fseq);
    self__.fseq = cljs.core.next(self__.fseq);
    return ret;
  } else if (!(self__.riter == null) && self__.riter.hasNext())
    return self__.riter.next();
  else
    throw new Error('No such element');
};
cljs.core.PersistentQueueIter.prototype.remove = function() {
  var self__ = this;
  var _ = this;
  return new Error('Unsupported operation');
};
cljs.core.PersistentQueueIter.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    2,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      cljs.core.with_meta(
        new cljs.core.Symbol(null, 'fseq', 'fseq', -1466412450, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      ),
      new cljs.core.Symbol(null, 'riter', 'riter', -237834262, null)
    ],
    null
  );
};
cljs.core.PersistentQueueIter.cljs$lang$type = true;
cljs.core.PersistentQueueIter.cljs$lang$ctorStr = 'cljs.core/PersistentQueueIter';
cljs.core.PersistentQueueIter.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(
    writer__7756__auto__,
    'cljs.core/PersistentQueueIter'
  );
};
cljs.core.__GT_PersistentQueueIter = function cljs$core$__GT_PersistentQueueIter(
  fseq,
  riter
) {
  return new cljs.core.PersistentQueueIter(fseq, riter);
};
cljs.core.PersistentQueueSeq = function(meta, front, rear, __hash) {
  this.meta = meta;
  this.front = front;
  this.rear = rear;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 31850572;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.PersistentQueueSeq.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.PersistentQueueSeq.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.PersistentQueueSeq.prototype.indexOf = (function() {
  var G__11380 = null;
  var G__11380__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__11380__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11380 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11380__1.call(this, x);
      case 2:
        return G__11380__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11380.cljs$core$IFn$_invoke$arity$1 = G__11380__1;
  G__11380.cljs$core$IFn$_invoke$arity$2 = G__11380__2;
  return G__11380;
})();
cljs.core.PersistentQueueSeq.prototype.lastIndexOf = (function() {
  var G__11381 = null;
  var G__11381__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      cljs.core.count(coll)
    );
  };
  var G__11381__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11381 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11381__1.call(this, x);
      case 2:
        return G__11381__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11381.cljs$core$IFn$_invoke$arity$1 = G__11381__1;
  G__11381.cljs$core$IFn$_invoke$arity$2 = G__11381__2;
  return G__11381;
})();
cljs.core.PersistentQueueSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.List.EMPTY, self__.meta);
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.first(self__.front);
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var temp__4655__auto__ = cljs.core.next(self__.front);
  if (temp__4655__auto__) {
    var f1 = temp__4655__auto__;
    return new cljs.core.PersistentQueueSeq(self__.meta, f1, self__.rear, null);
  } else if (self__.rear == null)
    return coll__$1.cljs$core$IEmptyableCollection$_empty$arity$1(null);
  else
    return new cljs.core.PersistentQueueSeq(
      self__.meta,
      self__.rear,
      null,
      null
    );
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1;
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.PersistentQueueSeq(
    meta__$1,
    self__.front,
    self__.rear,
    self__.__hash
  );
};
cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.cons(o, coll__$1);
};
cljs.core.PersistentQueueSeq.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    4,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'front', 'front', 117022539, null),
      new cljs.core.Symbol(null, 'rear', 'rear', -900164830, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.PersistentQueueSeq.cljs$lang$type = true;
cljs.core.PersistentQueueSeq.cljs$lang$ctorStr = 'cljs.core/PersistentQueueSeq';
cljs.core.PersistentQueueSeq.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/PersistentQueueSeq');
};
cljs.core.__GT_PersistentQueueSeq = function cljs$core$__GT_PersistentQueueSeq(
  meta,
  front,
  rear,
  __hash
) {
  return new cljs.core.PersistentQueueSeq(meta, front, rear, __hash);
};
cljs.core.PersistentQueueSeq.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.PersistentQueue = function(meta, count, front, rear, __hash) {
  this.meta = meta;
  this.count = count;
  this.front = front;
  this.rear = rear;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 31858766;
  this.cljs$lang$protocol_mask$partition1$ = 8192;
};
cljs.core.PersistentQueue.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.PersistentQueue.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.PersistentQueue.prototype.indexOf = (function() {
  var G__11382 = null;
  var G__11382__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, 0);
  };
  var G__11382__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11382 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11382__1.call(this, x);
      case 2:
        return G__11382__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11382.cljs$core$IFn$_invoke$arity$1 = G__11382__1;
  G__11382.cljs$core$IFn$_invoke$arity$2 = G__11382__2;
  return G__11382;
})();
cljs.core.PersistentQueue.prototype.lastIndexOf = (function() {
  var G__11383 = null;
  var G__11383__1 = function(x) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(
      coll,
      x,
      self__.count.cljs$core$IFn$_invoke$arity$1
        ? self__.count.cljs$core$IFn$_invoke$arity$1(coll)
        : self__.count.call(null, coll)
    );
  };
  var G__11383__2 = function(x, start) {
    var self__ = this;
    var coll = this;
    return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll, x, start);
  };
  G__11383 = function(x, start) {
    switch (arguments.length) {
      case 1:
        return G__11383__1.call(this, x);
      case 2:
        return G__11383__2.call(this, x, start);
    }
    throw new Error('Invalid arity: ' + arguments.length);
  };
  G__11383.cljs$core$IFn$_invoke$arity$1 = G__11383__1;
  G__11383.cljs$core$IFn$_invoke$arity$2 = G__11383__2;
  return G__11383;
})();
cljs.core.PersistentQueue.prototype.cljs$core$IIterable$ = cljs.core.PROTOCOL_SENTINEL;
cljs.core.PersistentQueue.prototype.cljs$core$IIterable$_iterator$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.PersistentQueueIter(
    self__.front,
    cljs.core._iterator(self__.rear)
  );
};
cljs.core.PersistentQueue.prototype.cljs$core$IMeta$_meta$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.meta;
};
cljs.core.PersistentQueue.prototype.cljs$core$ICloneable$_clone$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.PersistentQueue(
    self__.meta,
    self__.count,
    self__.front,
    self__.rear,
    self__.__hash
  );
};
cljs.core.PersistentQueue.prototype.cljs$core$ICounted$_count$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return self__.count;
};
cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.first(self__.front);
};
cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  if (cljs.core.truth_(self__.front)) {
    var temp__4655__auto__ = cljs.core.next(self__.front);
    if (temp__4655__auto__) {
      var f1 = temp__4655__auto__;
      return new cljs.core.PersistentQueue(
        self__.meta,
        self__.count - 1,
        f1,
        self__.rear,
        null
      );
    } else
      return new cljs.core.PersistentQueue(
        self__.meta,
        self__.count - 1,
        cljs.core.seq(self__.rear),
        cljs.core.PersistentVector.EMPTY,
        null
      );
  } else
    return coll__$1;
};
cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var h__7584__auto__ = self__.__hash;
  if (!(h__7584__auto__ == null))
    return h__7584__auto__;
  else {
    var h__7584__auto____$1 = cljs.core.hash_ordered_coll(coll__$1);
    self__.__hash = h__7584__auto____$1;
    return h__7584__auto____$1;
  }
};
cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  coll,
  other
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.equiv_sequential(coll__$1, other);
};
cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.with_meta(cljs.core.PersistentQueue.EMPTY, self__.meta);
};
cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.first(self__.front);
};
cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  return cljs.core.rest(cljs.core.seq(coll__$1));
};
cljs.core.PersistentQueue.prototype.cljs$core$ISeqable$_seq$arity$1 = function(
  coll
) {
  var self__ = this;
  var coll__$1 = this;
  var rear__$1 = cljs.core.seq(self__.rear);
  if (
    cljs.core.truth_(
      (function() {
        var or__7144__auto__ = self__.front;
        if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
        else return rear__$1;
      })()
    )
  )
    return new cljs.core.PersistentQueueSeq(
      null,
      self__.front,
      cljs.core.seq(rear__$1),
      null
    );
  else
    return null;
};
cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(
  coll,
  meta__$1
) {
  var self__ = this;
  var coll__$1 = this;
  return new cljs.core.PersistentQueue(
    meta__$1,
    self__.count,
    self__.front,
    self__.rear,
    self__.__hash
  );
};
cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 = function(
  coll,
  o
) {
  var self__ = this;
  var coll__$1 = this;
  if (cljs.core.truth_(self__.front))
    return new cljs.core.PersistentQueue(
      self__.meta,
      self__.count + 1,
      self__.front,
      cljs.core.conj.cljs$core$IFn$_invoke$arity$2(
        (function() {
          var or__7144__auto__ = self__.rear;
          if (cljs.core.truth_(or__7144__auto__)) return or__7144__auto__;
          else return cljs.core.PersistentVector.EMPTY;
        })(),
        o
      ),
      null
    );
  else
    return new cljs.core.PersistentQueue(
      self__.meta,
      self__.count + 1,
      cljs.core.conj.cljs$core$IFn$_invoke$arity$2(self__.front, o),
      cljs.core.PersistentVector.EMPTY,
      null
    );
};
cljs.core.PersistentQueue.getBasis = function() {
  return new cljs.core.PersistentVector(
    null,
    5,
    5,
    cljs.core.PersistentVector.EMPTY_NODE,
    [
      new cljs.core.Symbol(null, 'meta', 'meta', -1154898805, null),
      new cljs.core.Symbol(null, 'count', 'count', -514511684, null),
      new cljs.core.Symbol(null, 'front', 'front', 117022539, null),
      new cljs.core.Symbol(null, 'rear', 'rear', -900164830, null),
      cljs.core.with_meta(
        new cljs.core.Symbol(null, '__hash', '__hash', -1328796629, null),
        new cljs.core.PersistentArrayMap(
          null,
          1,
          [new cljs.core.Keyword(null, 'mutable', 'mutable', 875778266), true],
          null
        )
      )
    ],
    null
  );
};
cljs.core.PersistentQueue.cljs$lang$type = true;
cljs.core.PersistentQueue.cljs$lang$ctorStr = 'cljs.core/PersistentQueue';
cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/PersistentQueue');
};
cljs.core.__GT_PersistentQueue = function cljs$core$__GT_PersistentQueue(
  meta,
  count,
  front,
  rear,
  __hash
) {
  return new cljs.core.PersistentQueue(meta, count, front, rear, __hash);
};
cljs.core.PersistentQueue.EMPTY = new cljs.core.PersistentQueue(
  null,
  0,
  null,
  cljs.core.PersistentVector.EMPTY,
  cljs.core.empty_ordered_hash
);
cljs.core.PersistentQueue.prototype[cljs.core.ITER_SYMBOL] = function() {
  var this__8158__auto__ = this;
  return cljs.core.es6_iterator(this__8158__auto__);
};
cljs.core.NeverEquiv = function() {
  this.cljs$lang$protocol_mask$partition0$ = 2097152;
  this.cljs$lang$protocol_mask$partition1$ = 0;
};
cljs.core.NeverEquiv.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(
  o,
  other
) {
  var self__ = this;
  var o__$1 = this;
  return false;
};
cljs.core.NeverEquiv.getBasis = function() {
  return cljs.core.PersistentVector.EMPTY;
};
cljs.core.NeverEquiv.cljs$lang$type = true;
cljs.core.NeverEquiv.cljs$lang$ctorStr = 'cljs.core/NeverEquiv';
cljs.core.NeverEquiv.cljs$lang$ctorPrWriter = function(
  this__7755__auto__,
  writer__7756__auto__,
  opt__7757__auto__
) {
  return cljs.core._write(writer__7756__auto__, 'cljs.core/NeverEquiv');
};
cljs.core.__GT_NeverEquiv = function cljs$core$__GT_NeverEquiv() {
  return new cljs.core.NeverEquiv();
};
cljs.core.never_equiv = new cljs.core.NeverEquiv();
cljs.core.equiv_map = function cljs$core$equiv_map(x, y) {
  return cljs.core.boolean$(
    cljs.core.map_QMARK_(y)
      ? cljs.core.count(x) === cljs.core.count(y)
          ? cljs.core.every_QMARK_(
              function(xkv) {
                return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(
                  cljs.core.get.cljs$core$IFn$_invoke$arity$3(
                    y,
                    cljs.core.first(xkv),
                    cljs.core.never_equiv
                  ),
                  cljs.core.second(xkv)
                );
              },
              x
            )
          : null
      : null
  );
};
cljs.core.scan_array = function cljs$core$scan_array(incr, k, array) {
  var len = array.length;
  var i = 0;
  while (true) {
    if (i < len)
      if (k === array[i])
        return i;
      else {
        var G__11384 = i + incr;
        i = G__11384;
        continue;
      }
    else
      return null;
    break;
  }
};
cljs.core.obj_map_compare_keys = function cljs$core$obj_map_compare_keys(a, b) {
  var a__$1 = cljs.core.hash(a);
  var b__$1 = cljs.core.hash(b);
  if (a__$1 < b__$1) return -1;
  else if (a__$1 > b__$1) return 1;
  else return 0;
};
cljs.core.obj_map__GT_hash_map = function cljs$core$obj_map__GT_hash_map(
  m,
  k,
  v
) {
  var ks = m.keys;
  var len = ks.length;
  var so = m.strobj;
  var mm = cljs.core.meta(m);
  var i = 0;
  var out = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY);
  while (true) {
    if (i < len) {
      var k__$1 = ks[i];
      var G__11385 = i + 1;
      var G__11386 = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(
        out,
        k__$1,
        so[k__$1]
      );
      i = G__11385;
      out = G__11386;
      continue;
    } else
      return cljs.core.with_meta(
        cljs.core.persistent_BANG_(
          cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out, k, v)
        ),
        mm
      );
    break;
  }
};
cljs.core.obj_clone = function cljs$core$obj_clone(obj, ks) {
  var new_obj = {};
  var l = ks.length;
  var i_11391 = 0;
  while (true) {
    if (i_11391 < l) {
      var k_11392 = ks[i_11391];
      new_obj[k_11392] = obj[k_11392];
      var G__11393 = i_11391 + 1;
      i_11391 = G__11393;
      continue;
    } else;
    break;
  }
  return new_obj;
};
cljs.core.ObjMap = function(meta, keys, strobj, update_count, __hash) {
  this.meta = meta;
  this.keys = keys;
  this.strobj = strobj;
  this.update_count = update_count;
  this.__hash = __hash;
  this.cljs$lang$protocol_mask$partition0$ = 16123663;
  this.cljs$lang$protocol_mask$partition1$ = 4;
};
cljs.core.ObjMap.prototype.toString = function() {
  var self__ = this;
  var coll = this;
  return cljs.core.pr_str_STAR_(coll);
};
cljs.core.ObjMap.prototype.equiv = function(other) {
  var self__ = this;
  var this$ = this;
  return this$.cljs$core$IEquiv$_equiv$arity$2(null, other);
};
cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(
  coll,
  k
) {
  var self__ = this;
  var coll__$1 = this;
  return coll__$1.cljs$core$ILookup$_lookup$arity$3(null, k, null);
};
cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(
  coll,
  k,
  not_found
) {
  var self__ = this;
  var coll__$1 = this;
  if (goog.isString(k) && !(cljs.core.scan_array(1, k, self__.keys) == null))
    return self__.strobj[k];
  else
    return not_found;
};
cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(
  coll,
  f,
  init
) {
  var self__ = this;
  var coll__$1 = this;
  var len = self__.keys.length;
  var keys__$1 = self__.keys.sort(cljs.core.obj_map_compare_keys);
  var init__$1 = init;
  while (true) {
    if (cljs.core.seq(keys__$1)) {
      var k = cljs.core.first(keys__$1);
      var init__$2 = (function() {
        var G__11396 = init__$1;
        var G__11397 = k;
        var G__11398 = self__.strobj[k];
        return f.cljs$